{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 林业病虫害数据集和数据预处理方法介绍\n",
    "\n",
    "在本课程中，将使用百度与林业大学合作开发的林业病虫害防治项目中用到昆虫数据集。\n",
    "   \n",
    "## 读取AI识虫数据集标注信息\n",
    "\n",
    "AI识虫数据集结构如下：\n",
    "\n",
    "* 提供了2183张图片，其中训练集1693张，验证集245，测试集245张。\n",
    "* 包含7种昆虫，分别是Boerner、Leconte、Linnaeus、acuminatus、armandi、coleoptera和linnaeus。\n",
    "* 包含了图片和标注，请读者先将数据解压，并存放在insects目录下。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 解压数据脚本，第一次运行时打开注释，将文件解压到work目录下\n",
    "!unzip -q -d  /home/aistudio/work /home/aistudio/data/data19638/insects.zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将数据解压之后，可以看到insects目录下的结构如下所示。\n",
    "\n",
    "        insects\n",
    "            |---train\n",
    "            |         |---annotations\n",
    "            |         |         |---xmls\n",
    "            |         |                  |---100.xml\n",
    "            |         |                  |---101.xml\n",
    "            |         |                  |---...\n",
    "            |         |\n",
    "            |         |---images\n",
    "            |                   |---100.jpeg\n",
    "            |                   |---101.jpeg\n",
    "            |                   |---...\n",
    "            |\n",
    "            |---val\n",
    "            |        |---annotations\n",
    "            |        |         |---xmls\n",
    "            |        |                  |---1221.xml\n",
    "            |        |                  |---1277.xml\n",
    "            |        |                  |---...\n",
    "            |        |\n",
    "            |        |---images\n",
    "            |                  |---1221.jpeg\n",
    "            |                  |---1277.jpeg\n",
    "            |                  |---...\n",
    "            |\n",
    "            |---test\n",
    "                     |---images\n",
    "                               |---1833.jpeg\n",
    "                               |---1838.jpeg\n",
    "                               |---...\n",
    "\n",
    "insects包含train、val和test三个文件夹。train/annotations/xmls目录下存放着图片的标注。每个xml文件是对一张图片的说明，包括图片尺寸、包含的昆虫名称、在图片上出现的位置等信息。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "<annotation>\n",
    "        <folder>刘霏霏</folder>\n",
    "        <filename>100.jpeg</filename>\n",
    "        <path>/home/fion/桌面/刘霏霏/100.jpeg</path>\n",
    "        <source>\n",
    "                <database>Unknown</database>\n",
    "        </source>\n",
    "        <size>\n",
    "                <width>1336</width>\n",
    "                <height>1336</height>\n",
    "                <depth>3</depth>\n",
    "        </size>\n",
    "        <segmented>0</segmented>\n",
    "        <object>\n",
    "                <name>Boerner</name>\n",
    "                <pose>Unspecified</pose>\n",
    "                <truncated>0</truncated>\n",
    "                <difficult>0</difficult>\n",
    "                <bndbox>\n",
    "                        <xmin>500</xmin>\n",
    "                        <ymin>893</ymin>\n",
    "                        <xmax>656</xmax>\n",
    "                        <ymax>966</ymax>\n",
    "                </bndbox>\n",
    "        </object>\n",
    "        <object>\n",
    "                <name>Leconte</name>\n",
    "                <pose>Unspecified</pose>\n",
    "                <truncated>0</truncated>\n",
    "                <difficult>0</difficult>\n",
    "                <bndbox>\n",
    "                        <xmin>622</xmin>\n",
    "                        <ymin>490</ymin>\n",
    "                        <xmax>756</xmax>\n",
    "                        <ymax>610</ymax>\n",
    "                </bndbox>\n",
    "        </object>\n",
    "        <object>\n",
    "                <name>armandi</name>\n",
    "                <pose>Unspecified</pose>\n",
    "                <truncated>0</truncated>\n",
    "                <difficult>0</difficult>\n",
    "                <bndbox>\n",
    "                        <xmin>432</xmin>\n",
    "                        <ymin>663</ymin>\n",
    "                        <xmax>517</xmax>\n",
    "                        <ymax>729</ymax>\n",
    "                </bndbox>\n",
    "        </object>\n",
    "        <object>\n",
    "                <name>coleoptera</name>\n",
    "                <pose>Unspecified</pose>\n",
    "                <truncated>0</truncated>\n",
    "                <difficult>0</difficult>\n",
    "                <bndbox>\n",
    "                        <xmin>624</xmin>\n",
    "                        <ymin>685</ymin>\n",
    "                        <xmax>697</xmax>\n",
    "                        <ymax>771</ymax>\n",
    "                </bndbox>\n",
    "        </object>\n",
    "        <object>\n",
    "                <name>linnaeus</name>\n",
    "                <pose>Unspecified</pose>\n",
    "                <truncated>0</truncated>\n",
    "                <difficult>0</difficult>\n",
    "                <bndbox>\n",
    "                        <xmin>783</xmin>\n",
    "                        <ymin>700</ymin>\n",
    "                        <xmax>856</xmax>\n",
    "                        <ymax>802</ymax>\n",
    "                </bndbox>\n",
    "        </object>\n",
    "</annotation>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面列出的xml文件中的主要参数说明如下：\n",
    "\n",
    "* size：图片尺寸。\n",
    "\n",
    "* object：图片中包含的物体，一张图片可能中包含多个物体。\n",
    "\n",
    " -- name：昆虫名称；\n",
    " \n",
    " -- bndbox：物体真实框；\n",
    " \n",
    " -- difficult：识别是否困难。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "下面我们将从数据集中读取xml文件，将每张图片的标注信息读取出来。在读取具体的标注文件之前，我们先完成一件事情，就是将昆虫的类别名字（字符串）转化成数字表示的类别。因为神经网络里面计算时需要的输入类型是数值型的，所以需要将字符串表示的类别转化成具体的数字。昆虫类别名称的列表是：['Boerner', 'Leconte', 'Linnaeus', 'acuminatus', 'armandi', 'coleoptera', 'linnaeus']，这里我们约定此列表中：'Boerner'对应类别0，'Leconte'对应类别1，...，'linnaeus'对应类别6。使用下面的程序可以得到表示名称字符串和数字类别之间映射关系的字典。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "INSECT_NAMES = ['Boerner', 'Leconte', 'Linnaeus', \n",
    "                'acuminatus', 'armandi', 'coleoptera', 'linnaeus']\n",
    "\n",
    "def get_insect_names():\n",
    "    \"\"\"\n",
    "    return a dict, as following,\n",
    "        {'Boerner': 0,\n",
    "         'Leconte': 1,\n",
    "         'Linnaeus': 2, \n",
    "         'acuminatus': 3,\n",
    "         'armandi': 4,\n",
    "         'coleoptera': 5,\n",
    "         'linnaeus': 6\n",
    "        }\n",
    "    It can map the insect name into an integer label.\n",
    "    \"\"\"\n",
    "    insect_category2id = {}\n",
    "    for i, item in enumerate(INSECT_NAMES):\n",
    "        insect_category2id[item] = i\n",
    "\n",
    "    return insect_category2id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Boerner': 0,\n",
       " 'Leconte': 1,\n",
       " 'Linnaeus': 2,\n",
       " 'acuminatus': 3,\n",
       " 'armandi': 4,\n",
       " 'coleoptera': 5,\n",
       " 'linnaeus': 6}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cname2cid = get_insect_names()\n",
    "cname2cid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "调用get_insect_names函数返回一个dict，描述了昆虫名称和数字类别之间的映射关系。下面的程序从annotations/xml目录下面读取所有文件标注信息。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import xml.etree.ElementTree as ET\n",
    "\n",
    "def get_annotations(cname2cid, datadir):\n",
    "    filenames = os.listdir(os.path.join(datadir, 'annotations', 'xmls'))\n",
    "    records = []\n",
    "    ct = 0\n",
    "    for fname in filenames:\n",
    "        fid = fname.split('.')[0]\n",
    "        fpath = os.path.join(datadir, 'annotations', 'xmls', fname)\n",
    "        img_file = os.path.join(datadir, 'images', fid + '.jpeg')\n",
    "        tree = ET.parse(fpath)\n",
    "\n",
    "        if tree.find('id') is None:\n",
    "            im_id = np.array([ct])\n",
    "        else:\n",
    "            im_id = np.array([int(tree.find('id').text)])\n",
    "\n",
    "        objs = tree.findall('object')\n",
    "        im_w = float(tree.find('size').find('width').text)\n",
    "        im_h = float(tree.find('size').find('height').text)\n",
    "        gt_bbox = np.zeros((len(objs), 4), dtype=np.float32)\n",
    "        gt_class = np.zeros((len(objs), ), dtype=np.int32)\n",
    "        is_crowd = np.zeros((len(objs), ), dtype=np.int32)\n",
    "        difficult = np.zeros((len(objs), ), dtype=np.int32)\n",
    "        for i, obj in enumerate(objs):\n",
    "            cname = obj.find('name').text\n",
    "            gt_class[i] = cname2cid[cname]\n",
    "            _difficult = int(obj.find('difficult').text)\n",
    "            x1 = float(obj.find('bndbox').find('xmin').text)\n",
    "            y1 = float(obj.find('bndbox').find('ymin').text)\n",
    "            x2 = float(obj.find('bndbox').find('xmax').text)\n",
    "            y2 = float(obj.find('bndbox').find('ymax').text)\n",
    "            x1 = max(0, x1)\n",
    "            y1 = max(0, y1)\n",
    "            x2 = min(im_w - 1, x2)\n",
    "            y2 = min(im_h - 1, y2)\n",
    "            # 这里使用xywh格式来表示目标物体真实框\n",
    "            gt_bbox[i] = [(x1+x2)/2.0 , (y1+y2)/2.0, x2-x1+1., y2-y1+1.]\n",
    "            is_crowd[i] = 0\n",
    "            difficult[i] = _difficult\n",
    "\n",
    "        voc_rec = {\n",
    "            'im_file': img_file,\n",
    "            'im_id': im_id,\n",
    "            'h': im_h,\n",
    "            'w': im_w,\n",
    "            'is_crowd': is_crowd,\n",
    "            'gt_class': gt_class,\n",
    "            'gt_bbox': gt_bbox,\n",
    "            'gt_poly': [],\n",
    "            'difficult': difficult\n",
    "            }\n",
    "        if len(objs) != 0:\n",
    "            records.append(voc_rec)\n",
    "        ct += 1\n",
    "    return records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TRAINDIR = '/home/aistudio/work/insects/train'\n",
    "TESTDIR = '/home/aistudio/work/insects/test'\n",
    "VALIDDIR = '/home/aistudio/work/insects/val'\n",
    "cname2cid = get_insect_names()\n",
    "records = get_annotations(cname2cid, TRAINDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1693"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(records)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'im_file': '/home/aistudio/work/insects/train/images/408.jpeg',\n",
       " 'im_id': array([0]),\n",
       " 'h': 1504.0,\n",
       " 'w': 1504.0,\n",
       " 'is_crowd': array([0, 0, 0, 0, 0], dtype=int32),\n",
       " 'gt_class': array([0, 1, 4, 5, 6], dtype=int32),\n",
       " 'gt_bbox': array([[758. , 607.5, 135. , 150. ],\n",
       "        [716. , 770. , 157. , 147. ],\n",
       "        [965. , 695.5,  89. , 126. ],\n",
       "        [818. , 967.5,  93. ,  98. ],\n",
       "        [907. , 848. ,  87. , 109. ]], dtype=float32),\n",
       " 'gt_poly': [],\n",
       " 'difficult': array([0, 0, 0, 0, 0], dtype=int32)}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "records[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过上面的程序，将所有训练数据集的标注数据全部读取出来了，存放在records列表下面，其中每一个元素是一张图片的标注数据，包含了图片存放地址，图片id，图片高度和宽度，图片中所包含的目标物体的种类和位置。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据读取和预处理\n",
    "\n",
    "数据预处理是训练神经网络时非常重要的步骤。合适的预处理方法，可以帮助模型更好的收敛并防止过拟合。首先我们需要从磁盘读入数据，然后需要对这些数据进行预处理，为了保证网络运行的速度，通常还要对数据预处理进行加速。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据读取\n",
    "\n",
    "前面已经将图片的所有描述信息保存在records中了，其中每一个元素都包含了一张图片的描述，下面的程序展示了如何根据records里面的描述读取图片及标注。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据读取\n",
    "import cv2\n",
    "\n",
    "def get_bbox(gt_bbox, gt_class):\n",
    "    # 对于一般的检测任务来说，一张图片上往往会有多个目标物体\n",
    "    # 设置参数MAX_NUM = 50， 即一张图片最多取50个真实框；如果真实\n",
    "    # 框的数目少于50个，则将不足部分的gt_bbox, gt_class和gt_score的各项数值全设置为0\n",
    "    MAX_NUM = 50\n",
    "    gt_bbox2 = np.zeros((MAX_NUM, 4))\n",
    "    gt_class2 = np.zeros((MAX_NUM,))\n",
    "    for i in range(len(gt_bbox)):\n",
    "        gt_bbox2[i, :] = gt_bbox[i, :]\n",
    "        gt_class2[i] = gt_class[i]\n",
    "        if i >= MAX_NUM:\n",
    "            break\n",
    "    return gt_bbox2, gt_class2\n",
    "\n",
    "def get_img_data_from_file(record):\n",
    "    \"\"\"\n",
    "    record is a dict as following,\n",
    "      record = {\n",
    "            'im_file': img_file,\n",
    "            'im_id': im_id,\n",
    "            'h': im_h,\n",
    "            'w': im_w,\n",
    "            'is_crowd': is_crowd,\n",
    "            'gt_class': gt_class,\n",
    "            'gt_bbox': gt_bbox,\n",
    "            'gt_poly': [],\n",
    "            'difficult': difficult\n",
    "            }\n",
    "    \"\"\"\n",
    "    im_file = record['im_file']\n",
    "    h = record['h']\n",
    "    w = record['w']\n",
    "    is_crowd = record['is_crowd']\n",
    "    gt_class = record['gt_class']\n",
    "    gt_bbox = record['gt_bbox']\n",
    "    difficult = record['difficult']\n",
    "\n",
    "    img = cv2.imread(im_file)\n",
    "    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "\n",
    "    # check if h and w in record equals that read from img\n",
    "    assert img.shape[0] == int(h), \\\n",
    "             \"image height of {} inconsistent in record({}) and img file({})\".format(\n",
    "               im_file, h, img.shape[0])\n",
    "\n",
    "    assert img.shape[1] == int(w), \\\n",
    "             \"image width of {} inconsistent in record({}) and img file({})\".format(\n",
    "               im_file, w, img.shape[1])\n",
    "\n",
    "    gt_boxes, gt_labels = get_bbox(gt_bbox, gt_class)\n",
    "\n",
    "    # gt_bbox 用相对值\n",
    "    gt_boxes[:, 0] = gt_boxes[:, 0] / float(w)\n",
    "    gt_boxes[:, 1] = gt_boxes[:, 1] / float(h)\n",
    "    gt_boxes[:, 2] = gt_boxes[:, 2] / float(w)\n",
    "    gt_boxes[:, 3] = gt_boxes[:, 3] / float(h)\n",
    "  \n",
    "    return img, gt_boxes, gt_labels, (h, w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "record = records[0]\n",
    "img, gt_boxes, gt_labels, scales = get_img_data_from_file(record)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1504, 1504, 3)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(50, 4)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gt_boxes.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 4., 5., 6., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gt_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1504.0, 1504.0)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`get_img_data_from_file()`函数可以返回图片数据的数据，它们是图像数据img，真实框坐标gt_boxes，真实框包含的物体类别gt_labels，图像尺寸scales。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据预处理\n",
    "\n",
    "在计算机视觉中，通常会对图像做一些随机的变化，产生相似但又不完全相同的样本。主要作用是扩大训练数据集，抑制过拟合，提升模型的泛化能力，常用的方法主要有以下几种：\n",
    "- 随机改变亮暗、对比度和颜色\n",
    "- 随机填充\n",
    "- 随机裁剪\n",
    "- 随机缩放\n",
    "- 随机翻转\n",
    "- 随机打乱真实框排列顺序\n",
    "\n",
    "下面我们分别使用numpy 实现这些数据增强方法。\n",
    "\n",
    "#### **随机改变亮暗、对比度和颜色等**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "read image from file /home/aistudio/work/insects/train/images/193.jpeg\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "from PIL import Image, ImageEnhance\n",
    "import random\n",
    "\n",
    "# 随机改变亮暗、对比度和颜色等\n",
    "def random_distort(img):\n",
    "    # 随机改变亮度\n",
    "    def random_brightness(img, lower=0.5, upper=1.5):\n",
    "        e = np.random.uniform(lower, upper)\n",
    "        return ImageEnhance.Brightness(img).enhance(e)\n",
    "    # 随机改变对比度\n",
    "    def random_contrast(img, lower=0.5, upper=1.5):\n",
    "        e = np.random.uniform(lower, upper)\n",
    "        return ImageEnhance.Contrast(img).enhance(e)\n",
    "    # 随机改变颜色\n",
    "    def random_color(img, lower=0.5, upper=1.5):\n",
    "        e = np.random.uniform(lower, upper)\n",
    "        return ImageEnhance.Color(img).enhance(e)\n",
    "\n",
    "    ops = [random_brightness, random_contrast, random_color]\n",
    "    np.random.shuffle(ops)\n",
    "\n",
    "    img = Image.fromarray(img)\n",
    "    img = ops[0](img)\n",
    "    img = ops[1](img)\n",
    "    img = ops[2](img)\n",
    "    img = np.asarray(img)\n",
    "\n",
    "    return img\n",
    "\n",
    "# 定义可视化函数，用于对比原图和图像增强的效果\n",
    "import matplotlib.pyplot as plt\n",
    "def visualize(srcimg, img_enhance):\n",
    "    # 图像可视化\n",
    "    plt.figure(num=2, figsize=(6,12))\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.title('Src Image', color='#0000FF')\n",
    "    plt.axis('off') # 不显示坐标轴\n",
    "    plt.imshow(srcimg) # 显示原图片\n",
    "\n",
    "    # 对原图做 随机改变亮暗、对比度和颜色等 数据增强\n",
    "    srcimg_gtbox = records[0]['gt_bbox']\n",
    "    srcimg_label = records[0]['gt_class']\n",
    "\n",
    "    plt.subplot(1,2,2)\n",
    "    plt.title('Enhance Image', color='#0000FF')\n",
    "    plt.axis('off') # 不显示坐标轴\n",
    "    plt.imshow(img_enhance)\n",
    "\n",
    "\n",
    "\n",
    "image_path = records[0]['im_file']\n",
    "print(\"read image from file {}\".format(image_path))\n",
    "srcimg = Image.open(image_path)\n",
    "# 将PIL读取的图像转换成array类型\n",
    "srcimg = np.array(srcimg)\n",
    "\n",
    "# 对原图做 随机改变亮暗、对比度和颜色等 数据增强\n",
    "img_enhance = random_distort(srcimg)\n",
    "visualize(srcimg, img_enhance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **随机填充**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAADHCAYAAAAQ7YTfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsvWmwLVlW3/dba+88507vvqGqXr2q6uou6KbppruhQRJtbJBAE0YBAjssByhsB4TBMrI1hEVIwoOQFdZghQhZDqPAYWwhW5IjwAohQEYgLIGFZMkCCwtb3TQ9V1fX+OoNdzyZuffyh7V3Zp5z76uuFlV1L65cESfuPSennTv/K/eal5gZM80000wzvflIL3oAM80000wzXQzNC8BMM80005uU5gVgpplmmulNSvMCMNNMM830JqV5AZhppplmepPSvADMNNNMM71JaV4AZppppldFIvyMCN9+0eOY6bWjeQF4nUiErxThH4pwT4SXRfgHIvyG1+jcJsI7XotzzfTmIhE+IcKJCIeTz39z0eN6LUiErxbh0xc9jl9LFC96AP9/JBH2gR8HvhP4IWABfBWwesD+0Yz+jRvhTG9y+gYzfvqiBzHTxdOsAbw+9E4AM/5nM5IZJ2b8lBn/DECEby0awZ8X4Tbwx8vv3yHCB0U4EOGfi/Bln+1CIvxxEX5YhL9SjvslEd4pwneL8IIIT4vw2yf7f9vkGh8T4fdsnO8Pi/CsCJ8R4dun2oYISxH+nAifEuF5Eb5fhO3XbtpmukgquPy58ozviPBxEb5uY7e3FeweiPBTIjw8Of6HRXiuaL3/uwjvmWz7QRG+T4S/VY79xyK8fbL9PSL8naItPy/Cf1x+VxH+qAgfFeG2CD8kwo1XeT8/I8J/UTTxQxF+TISHRPirItwX4Z+I8NRk/79Q+OW+CL8gwldNtm2L8JfLvHyw8MmnJ9sfF+Gvi/Bimbff/7nM/UXRvAC8PvRhIBXAfJ0I18/Z5wPAx4BHgT8pwu/CF4J/B9gHfidw+1Ve7xuA/wm4DvxT4CfxZ/sE8CeA/3ay7wvA15drfBvw5+tCI8K/CvxHwG8F3gF89cZ1/gy+uL2/bH8C+GOvcowz/dqgDwC/DDwM/FngvxdBJtt/N46bm7hm+12TbT8BfEHZ9n8Bf3Xj3N8M/Oc4Tj8C/EkAEa4APw38beBxHFv/Wznm9wHfBPymsu0O8H2fw/18M/Bv41h9O/B/AH8JuAF8EPieyb7/BMf2DeCvAT8swlbZ9j3AU8DnA78N+LfqQSIo8GPA/12u81uAPyjC134O47wYMrP58zp8wN4N9oNgnwbrwX4U7NGy7VvBPrWx/0+C/YFXeW4De0f5/4+D/Z3Jtm8AOwQL5fuVsv+1B5zrR+p1wf4HsD892faOei0wATsCe/tk+1eAffyi53r+fE64/ETBx93J5zvKtm8F+8hk353y/G+V7z8D9p9Otv9esL/9gOtcK8deLd9/EOwHJtt/B9iHyv/fAvZPH3CeD4L9lsn3x8A6sHjOvl8N9unJ958B+08m378X7Ccm378B7BdfYa7ugH1J+f9jYF872fbt9VpgHziHn78b7C9d9PP+bJ/ZB/A6kRkfBL4VQIR3AX8F+K+Abym7PL1xyJPAR/8FL/f85P8T4CUz0uQ7wB5wt6j034NL8grsAL9U9nkc+PnJuaZjfKTs+wsyyoMChH/BMc90cfRN9mAfwHP1HzOOy7PeO287cFy3iRBwif534VjJZZ+HgXuvdCyvjP23AX9DZDgfQMI152cecMyUNnlj8/twbyJ8F/Dv4nxguJZcTVyPs84P0//fBjwuwt3JbwH4+69ifBdKswnoDSAzPgT8IPDe6c8buz0No0309SARlsBfB/4c8KgZ14D/FQYV/1ngLZNDnpz8/xLOMO8x41r5XDVbeznM9Oal3w18I24+vAqDbV0edMCEnsZNKw/a9nUTzF0zY8vsVb38XzUVe/8fBv5N4HrhjXu8Ot54Gvj4xhivmPE7Xssxvh40LwCvA4nwLhH+kIgDRoQnccn/H73CYT8AfJcIv04EEeEdIrztNR7aAlgCLwJ90QZ++2T7DwHfJsK7RdgB/rO6wYwM/He4z+AmgAhP/Jqwc870RtAVPMrtNq4p/qnP4dgfBx4T4Q+WQIMrInygbPt+3Ef2NgARHhHhG1/LgRe6AvQ4b0QR/hiuAVT6IeC7RbguwhPAfzjZ9n8CByL8keIsDiK8V16jsO/Xk+YF4PWhA9yZ9o9FOMJf/P8P8IcedIAZP4yr0H+tHP8j8OqiHV4tmXEA/H4czHdwqe1HJ9t/Avivgb+HO+nqglXDV/9I/V2E+7jj7gtfyzHO9IbQj8l6HsDfeA3O+T8Cn8TNMv+cVxZ21qjg8rfhwQzPAb8CfE3Z/BdwjP6UCAflvB847zy/SvpJ3An9Yfw+Tlk38/wJ4NPAx3Hc/y8Uvijm1q/HHcgfx7XlH8A1oUtN4g6LmWY6SyK8G1+4ljbnKcw000AifCfwzWb8posey6+GZg1gpjUS4V8ravh14L8Efmx++c/0ZicRHhPhXyl5CV+Ia/OvheZ0oTQvADNt0u/BcwU+ikdbfOfFDmemmS4FLfB8mgPg7wJ/E/iLFzqi14BmE9BMM80005uUZg1gpplmmulNSvMCMNNMM830JqVLnQn8oQ//soUQgOxpy3FBSh2qilmiabZpmoYYI6vUY5YwFUDpuo4u9bRdR84ZESEhQKazzJYKyYSce8yERgPN1pLdZslisUCCErJyenrMVlhiIRGjkLMH6Ztus7O75LQ9QE4TnUFKCaSn7ztElJQSkhIhBCxlUOH4+BjkBMs9Bwf3SEeH3D24z3L3CvtXr7NcPsTV/WtIDCRRQgjsNgEzo++M2AhBlEyC7Oa7jCFEsEwIwbehkA0TyDmjWtZ687yWnDOWMyd9Iljm8F7Hqn+Jw7sv0XHI9euPEuOC7d0dNO9hgt+HCNVsGEJAJJJVCAg5Z5bLJd1Jy2JpLLd3Ednl+OAO+488xCmBkzvH5NU9cneChYga9H1P3/d+j31PCIKRsayYCilTnqEhEnyeLSKaCAar1YoYtdyn36YSyNnnvG1bwkJp2xbJShClJ9C2Lb/xX/6KV5Oo9JrTjO0Z25cB25d6AYhRAcMMFosFOYOULCmROExMnzNkIy6U1BtdTpglpImE1CE4YDUKfd/TaMREwXpUlZ3FEjFomkgWQAVNiZPTE0IQRALklj4tUFmyd/UKfTrh5OA2ffKnYpbIOZFT5zjMCawn9Ubft+R0Sp9auu6E5194jhga9nZv8PAT7+Vm3GLRGLu7u6gqKa2AiCJYEsgZAWJTmVoLUJ35kUzGAMX6BBgi/QBmDRFMEM0Y2c/bQMyR0AREhJ3dbXLeo7/5dk77Q+7ffpF21XJw5zOoHhG3r7K3cwvRyNZim9BE+i4RojojJs/UTymhi4DFnsOjUzScsPvQkrRSmtMXWF67xmm6xcHt25BPIESWIdB1/vILwcEtCiKGIcPLYLHY4vj4mK2tLbr+BJUtunZFaBos94VJFiQzggqhibRtS9SAJmFbd2ABOUPuOna2Fm8soCc0Y3vG9mXA9qV2An/sEx81KauymTMH9OSsxBiJjaHSoKqICL31GEqbMim5lBTjgnsnR2yHhmw2SAwpJUzNpSyJ7OzscP/okMff+jbuv/Q8e3HJqvWJ3w4Nbcg8dONRkmVO7t+m6zpCXNC1J8N4zZTcH/lY+swqHZP7U07v32O1WrG79yg7u1fY2bnCcmsL1YjkRMZXcyvjE3FmcEknAQGVSLYeUSVbh7BAQ9mfCJKQ7GV5TDIaDEsgBkSXKgFUI7lPaHTJTdQlMC1FXyoa6rwnhJPDI05Ojnj59gu03cvsL7fZu36LEHeIDYS4RTIjxkhAMWkQCVhl1CywyCyaXUKOSD5isX+d0xw4feZTdKHB6CBB27bk3BNCIOWW1GdyhrBoQISUbBhbzpkg/pJanZwgIkQNmJTfVcgCapBMaNueIIk+g8ZAt2r5l379b7gQDWDG9ozty4DtS78A5JwhKAFBETKClhU0Z2WxWLgKGKBLLal34J+etvSSSMno8ynkSMoZUSOoFVW7IYTAznKL09NTokBcLlgut5E+0/YdMSoh7rN3dZvV6h7t0crBkzNd17GMQkqJlBIxKn3f07Ytp/ef497JEV3f8pbH38vO7jZxGWm0KeqrM4OlDCiiCcsR8IdvZqCCmGCAKKhFMkZKRghVpQx+vPg4mhAZ6sDlco6iO6bs4fz1pUI2RBsApJgiGCq9RSjh/y65QDU/vPzSixze+zQaT9i58jDN9sNsLxpAUY1YkWarmu9MnzETsrU0cRfLLTu7DXnrBu2dA05PbxOIpGR03WpQm1Pq3ESyXNB2ziBiOAPkTKQwc0r0fc9iETEzgiiqSpf8PP6CrS8dMPP5+tIv/dILWwBmbM/YvmhsX2oTkBhEDQ7uoP43BiwbqoGmGX3YBoSgmAhd1yFiLsmIklNAQwLz44I6c2BKbKDvWyCTELZixNIK0S1EWhY7V9nd3uL+necLUFwddHbNdK1hZLKdcnx6Qn/wEgf3erb2b/Dkk0+xs32Fqa0XEyigiTGQLeHh9rEwg5ATpD6xWC4RMyjqvaOvQyTSdYmgLjlqyIVxIsky4EAKIRYJ0+dIJRSw+IRV5jEzjAJAKVITzpxWTAwAIpkY4dHHbnLr1uOs2p7nX/wUd178KNdv3iAsrrIVGkITMVNQw4C+dftp3/cEiVjqEQkcHmYWqxdZ7t8gLbc4vfMCpJa42KJLJygKQREx+t7NGCklVITWDM2GoYAQo7BYLOjbFRqURbMYVG8xyBTzShBSl0liLLaWry+AX4FmbM/YvgzYvtQawCc/8THLuC0zpwKIGAanj5mxXC59VQyBnHtSMtrUs0qZLrkU0XVjJ0YRYbHYIkZXF7uuI5sQF4ku7/L5tx6DBu7efZ4rO7eQBRzeeZaUMpYFFSP3Kx9TznQnPavuHrfvfRK1qzxy80n29vZYNA9olCUdwKDu1fsyzWgeQamqqELfWpEKpfq4/KHnDGojqFUxE3dmmbkUaX4tyaHwZkBkfN4iAhZdRZ38VqWKUboAIfl3bdwGLWGQntrU8tJLz3N8/3l2l5G4e5XtxVUkQNM0tNnHp9KUsbrcocX+2VvLMi6h2efo5ecwYZA8u5Rc7VW3AWeBbEKXE1HcGUhRl6vUqVoYtGDbzNyZKDLY2jvzl92Xvud9F6IBzNiesX0ZsH2pNQBVgxwhg6r4zVsBCTaoYCmlYYWH3ld3M6IKqe8IoRnsj03TsLXlanFKK0SX7O9d5fqNa7S24uj2c7Tscu3hW5z2K9p7d7EkBG1o8xFikdRDLwccHxxyeP9lmrjLrUfez/7+PjH6lBpFPSMOUgcwONYAzDJIIpshKdLnTIwj0Nu2RYMgugVkqKAtKnStVBvj6PCpjkS3ffoLRIKBWQG3rjGBaiInG47bpAoqJGD4ecAlD0sZw1iEyGM3HyffeJTnn3uGey89y+nOXfauXCfnPZaLHXJegWmJVfEXXyrXW+gWfZ9I6WV2ru3Ttj2ro5dptpbYyh2FOXmkhFnGLBCLGkxOSAhuejAjNv7yWhBYkWhMWIkByVs3qdvVSR6hcVE0Y3vG9mXA9qXWAD71yY+YJEMEspbVWj00rkpG6AgKU6Er9rXVagXBAdH2LnVsb28XdbMFa+hVufXokwRW3L3zHJYXNE3D9vY2p6fHiCUwn3RJPUamXR1wcHiXw4OXuLL9CNcfeSvb20tEWWMKwaWqKtnkXNTr4uxBuqK2lpAuMikJQUCCjpJgDoi6HZDo9xmsSAQ2fTnA2IPD50vzGBbnUpSdwwj1mDHiY1NCWpOWJsen1JXoDYoUFEhFvb79wrMcvPQcO7tLrl59FF009AXIumhQWeKhb0IokR9mbutsmobcLzk+uYdoIsbIycnJYGutTj//v4TtFcmqKQ7VVYSAINn8JRRc+sxa5qpP5Jz5kvd98YVoADO2Z2xfBmxf+gVgcISE0UEibIGsiDG62qZSvOhVlTPadkWXMzlBzsrO9h59OkXNH+hy7wa7+zvcvf8s+cS9/NIIsmqxELHCWDlnYlZW7X1W3cs888wdHnnkER5+6DGWy21U3P5ZY5KFBRV4btMr/+eq4/oYczKCbiPSOigrSFNGJKCx2DRNB8eXEDCSSyjCGnBr6Nz0ecrELrr5nIUwzBVAKsMLNsYl+3FVehqZfHquNvU0GhD1iA2VBaIexy0i3D+6y/MvfJire9dpFg+hsUPZJkRFULrY4K46v/++79EkGInlsuH+/ft4fHTnZoPemTPnvqjFo2SoqliRhmE9Rrwr40kRui7RoGif+aL3vufCFoAZ2zO2Lxrbl3oB+PTHf8W09xs9VQey5kQXlGWzIOdMsxjtkQmj63va7pQaY516Y9E0pCDEvEVnxzz6ls+jTy2Hd+84c1RgZKNXaMyjFRp6+pxoTzueee6DKDs8+dS72d2a2EAL6GEdiDmdnfthRU9GX6IV6oMUwgDYKpXoZJ91cObBVjmVWqoJ1OTBCd5mabBTnkdZqyQ2/ALo2rWdSvRFiRCZjm9T5W77zIvPfoQ2r3hoewfZuubmBFn4ccEjKkaprh8iH5bLJaen7sh0ZlmRck/XlvtJfbGLCqHzZKGWjJYxpKLmZ1xC65mMs+t473vfeyELwIztGduXAduX2geQk3jkQLmNZRa62CB9T1JPhrHsmYmGki17/Kw2pJRYNA26VE5I2CqRtrd4/OGbHBzcJq86NMYhLE0RcnBZpcstKi0nx4n79+5x5/bHePyt7+fq1YdKAo/HHKfUgY1Ou0pmAkWy6RQWiYk6L+QIUTNWsxuzh/6NTq4aH56wohLDVEUNRTV2wAYLrCLENIJ0Cth1mjrWbI1RK3OIKEnV7Zr5dDiPM+s6Q4Tgcd2qsZwnknMaGEVEaILw2FvfydHhiru3P8x2Fth/mCWZTkGLc9DjrEu4nflL8fT0lJ3ta/R9ouuPaWIkpAWE1qXn7BEwkiEHb0y7pZGkeMRMbIp6LAiC5TTMRI4XVwllxvaM7cuA7UutATzzkY8asTxsSyUV3OOm88LDnFSEPggheogckui7TAxLf2CpI4ly/eZjSG45uPMSVMdTISkPNZRogDZn2qM7fPgjH+Kxm49x67HPZ7ncZiiLb25r25RezGzI7DNhUNEqeHyfEUDD9UWG1bsRHUCbJypf3e98W+fnRuedY6omrzFQSaZxO24ibrR4nTLaeN4yt+L3mlN1/iVUdrj90gt09hmu7TyCLXZBfG48pJBBQku9YKxo25blcnuQlsAlwr7PWF5hORKsXH/p0RiYYX2itQ5prmD96XCfMUa6zmOw3/eF774QDWDG9ozty4DtS60BWMgeGSFe2wQrD00VoXdVSyHkBF1ACaRsaGyQ0JAwejI3H3qClI44uH8E6nbM+kBDCCTpUVNSNnI65v7t53n22Wd5zzu/jO2Hr9MklxxyXhTJ5awEknPm+PiYGBcsFn4NB3kghGbYTwogNgHfiJDLg64MMh6zzijVTnp2worEViW5wvzD5uQx5SKZjDvk6tgBVEFzJKeMagCDkAGEpAERPF57QvX80/BFqI478XOEOgavcfLwzYc4Otrixduf5Pp1gxhY6i4ZsNwQiu2ZRrG+IUblpF2xs7/N4b0VUToyQmiU3DVkMl5QQEgF/AsJrBRgWWqzVMdjHhJxLlL4mbHNmevM2H7jsX2pF4AkgZh6UhSyRrJBY9BbprHotkgTquqXzetlVM/6ooGHHnmStDri+OiE6QIfQkCykG2FWU/OHZqM289+BNNdvuh9X81iq0Gyr/pt6kEExNOvnTyRo0Zt7Ozs0HXORE2x41aJ6DzJZKr+dlYe8wNsjVOqDDIUwdqctyJJ1KiAYEXaCp68YqLuMCz3UVPOMUiaQauSTxVSCRmixgFcqUSGRMYSBDA6pzzBRtekvRC02H9hf3+Pne338NwLnySGFt0RIjuotPQSQEBQVD3uGyL9Scf1q1c4Pj4mtafFLpwIQYq9NtK2RQrK2Z2OgCD05eXz4IiRN5ZmbM/YvgzYvtQLAIAtlgQRQt963QuNSLnJPicPsxJXf3qMJignfUvUhquPPMrJ6g752B+qSxhGwCWAbB2SFLoTjk9Pee4zH+PJJ7+Y3d0rJebZSmwwNFpTxvHF3xIuCcngsBKBvvfEnKZp1kBcQ/08bHkazSAFbG4PNhXPBn3AfLhK7Q88bZyjqpeDminjXxFAgmdRGkP0RZo41UQEKQxmVpk4D/tpic/OORMt+zxkT+qZUmee3arZNlT9jBnkXJyAC+XRx9/G8fExB3eeZ/+aEsM2UqJFOm1pVFFTmsbjvrvuhJ3tPZomsFqtyDkiZZ+UvFRC13nyj0UlSrHfynrkRAhhyAK9KJqxvU4ztt94bF/qBUBDABJ9P3EYpeSxtEGIYUHu+lJPxVfxVd9iGfZvPUZ3coe86ugLOLxqoJKLdz1aR0qJk+N7fOaZF3jnF/46trYWQ7zzoLImJWs/UU1LZIMZIpkalaGqbF/ZByBJWZVLfPAYeXCe86r8boYUcFqWIfRhasM0M5qSNESZk1Rqr2SpDOMHxMLUScdY6vpCERPUtIy/kk0YbH2Mji2PmvBkEwdcJ56e7wk0Iwh9CBt2U6qt2AuaiQQWIaB7eyx3tnnx6Y+xe+WA5WKPrHs0YiAdWEC1ccckytHxPfav3CAur3B876Uyd5GUT8ip1HcxI+RMFjdXJNIgIY2RKA8A3htAM7ZnbF8GbF/qBUBEwIoEklrSMhLMQBLkjOEFsRpV+hDIXY9p5pFHn4R0ymrlyRFiholBSV6JJMQyOQgvPPdRYIt3ftGXe7El8QSLKsnknEFyUSmriuXj8z10cCj5tzwwhRrkcp4HqbTDNcDrkVdsBpdIyh7DOXLOA9MgtXZL/UGZCGDYRh3x+rhzHpmlRjhUSuJAb3K5lo6q7jR0L4uCBtSm91Xtu57ZWW2T0q+r0B5mp4VZEhaMhe5w68m3c+fuC6TDE5ZXINgeWgp6IR4rLdKwXAonR/dY7kaavYfpjl5AghB0Qewyqxiwvi/x5F5ugFyvWeLOU4Z0cT6AGdszti8Dti/1ApAxVD0uOC0WLAlYEMwtaORkZPWH3XUrRAKPPvIkK45pD449xM7MbYIIaCL3rk7n0/t85umPcOOhp3jo5qMIC3KxeU5B48yi7sQRc3nAzJkphiFTsKqXNR3dcFtjKI6xPBhXa0haLucsqrGN250ppjHJJeHDANFBhQ5Vlc3rDrIpncecm7+tfy8x0AroeK0Ghewp7kJEtBsiKOpxUyaYZoeGpkgq4qr9VGI0M6QH0VNCiDx04xbHx6cc3/4w8aEFZk3JRMVtpyX6IiwCXXvKYtGhuzfpTu+4xKgZzacsaohcseMuq7Ou1GyBTNMELopmbNfvM7YvEtsXqAR/dooxYgT65I6alL0WeLYOo0c002xte/W8ADdvPkbPIaf3jn0VR8sqrogEsCVIx9HRMc8++wkeeuQL2H/sSVQaICMJgp2dkqyCSQFuUUmDCBEZACYl9b2qwNECDRGLkIMzWmUAESOJDkkt1YFT095VYwmte2WAZ/XOSkkz9oCl/LywPP9bHVCvjpIWJ5okatEvgJAVmczZGHUxRk70CBZiuT/1l5oVppFRgpLUEyyzs7PFtetfwPFBC5wgKGJSzBc1BjsAW3SnWyybU5bLbXLuCU0kxLGImpmXUQhe8gszd6yp6hCadxE0Y3vG9mXA9qXWALrOq+Y5YxhBldSDmdJrZLlYkvoOTYmbt95CZx3375wQG8OyFscPeFXAE9R62tNT7j77KR594m3sXX/E1TmrmXQUD1EdgWIYIdfoBW8iUR1PJpTqIAwJIjCml3tY2phpeF4InGpTfrPCRkK2MdZ6un+lUKSiHKZq54Ptr5TzqhWZRkYVXNcktNHp5lNxfkTBdP9J/a8HSl9DDfjh/GW8qZoHjJpkU4ugNVd22GmU+3c/zbVrDdA4zOtwivkETRwfJbauL7D+KjndRYMXRmvblmahWMr0BosS6fFKUShvFM3YnrF9GbB9qRcAr4RoxVGixXHlwIuLLXIS+hx5+OYtMnBy74hFiKQ8PsQsoHIKdLSnidvPfYi3PPk+lnvXiSU22fAHH1iXGoZEkCB+ovqgVdakAKiAj8NvNizAoyQ0TZoZxjdRJw1zG6jpGA9n4pJJIVcFyzVZZ5ApwCsIBqDLJD1oAv663aqqzdmCWdNrV+fhKzHSJtOdp6pXZql21SAM0Q5aHG77O9sseIr7B59kd/eRwtDjPfvFIqqJk9tH7F67Tne4Q9edoDGw0CV9d+pPVbyFVNAGxNsSsvG830iasc2M7UuA7UttAvLit14LvD6MnoAutr1Lkq3Yu7JDVrh/8Mxgb1Sr1fKSt6VLkE5WvPzyL3Hz8fezc+UaQYzOsttMq6PK7MwDHn4XV5fXqhmaDPvV2uWDY2YC4Lr/g2yWg6pNYOAuSSAuIdYxTMG5SeeNu/6/ed1RVR6lBdGM6BjpsLbtHIniXEYydemFUf180Hir0y2EcEZd9R603i6v2V5w9erjdCcvoWkFeMakUQpmxaJuL5cc3T1ksb9PCA21fnzQhb9UZUGgQSUjFhETsO7csb0RNGN7xvZlwPalXgCcKRKd9eQMITQsFguaJgxOme2tHQ4PX4C8XUKpxpCy6vTq2lOeeeYZblx9Pzt7+6Buqws2qmp+vVDA7qFflYKBmNsvB/BkG5NQCk2jAM67l+nfKXMAvnpTwaPujCqf82x6D5JgziMzQyW6PdjWpbbpeauKOt7L2XGfvd/pIKoddUxpD3ndNlvtxFJCCc+/J38Z9H2LWGKx3GW59xYOVnd8znMeCpKZCUEiIYNGoTu9T3P1hjNANkKEGHbOjLtpIkEvsCPYjO0Z25cA25d6AQBK9qHQ5kQSaEKky15N7/q1m9w/PkD7vhRtUnIQ+iJZNGpYf8Lzz/4zHn3089i+egXPmuhLpIKCxpLOPqq97oACYoAYsKBDCVuX2ARUSgKMFsfWdCrPTymf/k2MMbuu+oI04hgCn8ElAAAgAElEQVQOUkLlvEmESx965nyvhjyKY2zkoWFdQqnS15oEFh4s1Q1UxlTHkliXmNyGWUwM9ZD68rHRCTh9WXjkiGATZvGoi57t7SXbW09xdHoI0mIR2pzIuSdZj8QlIg1dK7THL7K88jgdHaKBuBBCxMsXZ49HTyldqBMYZmzP2L54bF/qBaDv+0HNWy6XBFF6MVh1LBcPu/jSnpLZG+2POWGpJVjP0ckJzz7zCa7svZMr167QhODNEsQfasbV3zUVk4BYJmrDtClDdX6NwCmRGGeAtO4IEykVHzciMOq2+gkZNCuq3ggEyQ7oCupz5mca1jctxFXnbPgEZ4SgzRn19zyGM9wsnOWsNLd+E5OXgXgdl5qwc54UV5nTL6KT/YpkqYGMkIr5wiUlx0DOsLu3zf6VJ2i7IyK5hNwVaS53qGYyB6ROaeJ9tNknp94lshC9LG/0T62ZclE0Y3vG9mXA9qV2AhOU3HkXnRgXhCbQrXpio+xejdy982ka2cGkJ4u6g4UM0tB1x7THt3nLW95Bs7MPIvTZoxdyLvHKAqQ8wrqEp4mURAtqJINXSvSHlQZ1+TwyqS0gRgCpQRYBvLkE4D1YNQyrtYXS8INUipUEwGOzTbx36FAQi3wOENdL4K4xAhERSJKAkfFr+LaIDL1aRYpMNVzLnXQDo9QMzWLDJnlPUzGfo4AMx9bRDf1CyrhtLRYcRCi25cLkxf5s4gzbdbW5OIStBaF9hNOT22zvXHWbahpj1puwT6Lj3t1jrt+4wcHBDn3rrRO7DDm1qCqLxeJCF4AZ2zO2LwO2L7UGYGZD3ZHFYkHf9+TcEuI1To+PCLozxERHIkNWYU7cufMMJguaratE9XT5ofuQuWe+FkBJAqhikktM9DgtHuZVbYeuUj/IcSQia4WoAEwCJoGAw14lFqCVxJGiqtVzmlmRPmoInk0ktSJF1WtarWi4cfyZiXT1OAzlb89S0GZQpz8bmRmKv5BEbZjXzSqOlTk256T8So2d3owzHxyRpWyB/+aSoJmxtXeFnbBLbO8RckcjdXs1OwSaxRb37r/M/vUbSPRnE2P0JimvNFdvEM3YnrF9GbB9qReAemNbWzuDE2y5Fdm52mDpAM0RLSFeYomcwboVB0cv0XeBG4+8FY1eJIvsfUxr3G7ONVuxhJgJ1Omo9kNgcFLVSIiBNmyX0+9mNvkuMCmGBS4dhRpxYS4JiQgq0eukQHE6FccTlQkMl5yc0cxsAOKD4p3HY8FwdRFAN0rflrOcOWbzPrP1a+qxp6EEVOIYIVHGruTJfYz23k1Vffo3hICJIiGiASTUTNVAV6JeIkbYf5iTHFE9RcUQU7Q44irDqDQc3n2Bnb2bbkbQnmax9OfRZ6JenA9gxvaM7cuA7UttAloEX9WCLuhXh6526XVO7t8GW6KS3G4KBDOEntP2mJdeepF3vuP9SPBwuVTjkc0hW+uN1AYQVmysoz0wlzrfr7A+VqAUiaeC1bfJGH892C4LeFUIYkUBhhii2yTroVGgPZ1IZhNmk+H05Z/6feqMGh1wlZJlAmHtmpK96cSDJD5MUJVBSsu4FJOsRy2cW7fd1Fk4IGtJPjFDX9RgH9sYqVFmGzUw685IjRDppSfl3huGl3onyxBh5xanhx9HF5lGjA7DrEFECcGrWZKEhd5j1exA2yPRpdDQZNrPIVv0taYZ2zO2LwO2L7kGENiOW+TuENVMahr29oU+FycRVtbo0kiCFfdeeJonPu9dSBPdBprBve3OHEmgIdIQvQFHmK6B6/Y7H8O6Q+vMNjWPMSYh1g/7mdmY+dcoISoapDjpChMBp+LRvz1uCdSaMzm9VpGWRD1GuMZRb45p6iTbHGvbdWi5Rgu0ajSNEoMQVPxvWD/GjOG6Qfwem4DHbwcfkzvUDCShzkrD8SEEslQGGce4SVFtcObBeoRGvR8odW7Eoxy8Z25Ad54i5OfIIoRprRnJQwTLvXsHbO9doyeN9mAiMV2kBjBj2y80YxsuDtuXegG4urtDNu+PKRa5eeM6h4eHxEmd71q7/EQ6Xn75RW48+YXsLW9Ab5iEgTEsjJEDSTNJz8Y5m8nAVIMHfsOmtskwlSFcVRy7IzXLBYuFMwg4MGtqRsbBel7FbtF11XHteubX2JSCzlM7x/mpkkCxIVPstQhdAbAFtzOq4L1kZdSOk+kQ6SE5lKRR85Az8RcUaf3FUucz9YbmQCbAJBbcY7b9XlQaZ7Q8tiDs+/7M+FWViFezrL8HUZZbDR03EY5QElEyaj0hq7fSC4rGbWhfZLF7nR6hUYZolIuiGdszti8Dti/1AtDpJFwuBu7f+QwLFSJhCOUSEfq+pzt6ibjYZXv7KiItgDfIMIZPzGO1Pl95fUVVhZx7zFLx2Pvvwrq99Dyq27O4BKQGcREdYKhLJICcezSDA61+qq1yKm0N3zUj2q8ltZwnddTxjtJSHtT4TVhUN1cLdGWfoMGZRiE0JVEnaJFKPdYYrTp6IjYbc2MK1kAEi0YUdyAGNaap/7X4lpp3bqpjnqrKIh7TPWq0nlKfUscqt6jCYv8a+TgT8IYlsglrEY5WPdsLQWVJT0bjAk0PeiqvP83YnrF9GbB9qReAkFYEUaIGtra2CLpHEqWz7GFxBpIyqT3g+eee4+r1tyESyCaDdJTE09yzCimMHYfcRqdDjLWq0ogOTCQiGGOP1E3HUxJXCk0iJhHMw9GarehSGetSUFWLh3tjZJzAKDnJBjttqry1qmIdh588QGnqvRnb7BJV8IqB2VXlDWV/7VuefNIwbjcHWFQyDf00koRAsnXJMWkm65i5WtX8aleVUnnRHX5LP05LLfYz5YrLMSHSI4PEmynVMPvEtkaaK49xfHyM0JLUhoqaiJcBwALHR/fY2t9HO8NSh11gOegZ2zO2h1FeILYvtRM49ZQYWKFtfUXMIkVFA8h0dsqzzz3D40+9l6ZkGFaqoWR9idMK2duodTkVIFWA+ENPkouk480nzos4SAU2WqxyCZdayCASz1V9KVeqclklBcaE7UzLWHt9nXJJbR+TXXLOTGurqC7Ove4o5QUkeS0XK+P4bG6iOpuVUbYUWvFqlFXs0qnU454yd1rqgxtTD79LQqQ04GBd3Z/uWyUnV8/TwKK12FZKRtxNNP0NmnQCGkk5YCii/rLLQUkJFvk+x9s7yMkxTdNwUTRje9w2Y/visH2pNQDJRlCQRV351YtguZ5Gto6Twxd57NHH2Vnu4JJCxnLvXYtY9+YndbvgWBOlPjCfbBtayT3Y7liLcTkadAhbG2KHX+F+XtkqpwNo1zIdi/323Bjt4jDD3O54XnldB5iQc1/UXKdN+FZmSEwZozC3uSS3wp+JkgZJZ3081aE3qvabNLX7uqlDkWyD/fM8mlaVlKCsa7fuBI0W2Nq6xt3jFpEODS4p5ZLEE80IJI7vH7C3sw9xieWLKwY3Y3vGNlw8ti/1AmAwSAS10UJ1YpklrD3hzp177F59vMS9+oQhgR6jx6siSsruZJFaclcK+BIiaTjng2yOwFmmKYDQYFCkqwRYm2hstHsugC1c1Vq3hzpNseFyjmI6xlaLeLz4VPXNAhTHnxgQvDG4iie81I9JRGMEjZg0RfV/ZdoERCrXSwah8EQNxztDNtZmmc7bmUgT88qQ5yfRnE+jc3B0Yk7P3yZvxL179RZHRweIdmBCyIqmSQRJXJLae8TlXqnIeTE0Y3vG9nDqC8T2pTYBheC1QxRPsVZVr6NukFLm/r1n+fyn3uvShLWeDNP3pV/nGHaVciZb9kxFlEgmp0QjJWZYq3Tx4PVwbAnnFMVVwszo1Mk5Y1pV7LLfcIQ33HBZSQdGWcl41YwzUAzrjyVnMPMaWinlITKh14QEQUVQUcKGpjye14hR6VMm9R3Es+phlXc2LYf1u4rXmKnnHCJEpqaEVxtVM5GuNqM+pr9vkqqSkyDSkct1QzUDZFAxlstd2tUVSB0WAppHZ2dllNPTU/avXuPe6uKcwDO267VnbMPFYftyLwBbC3Ln4OzpcDVYyBjHx89xeCTcWmxTbWXg3Xc2F78w6WXqWZIZBGyDOR4oJVkogQEl3Ex1YI5KUybK2VAE1eq+oiSRjNeqpBv/V1V1QxMcvyfImly6MMXILBql46wabuun8MgP6WuKECAPZA61dRODDUpz+b7JIOeRbcyRjOcGqPHe59F5NmrA1d8kQMAskyS7g7LajgPs7j/C6uBFgqVBOtw89/Hx82ztPvHgsb/ONGN73DBj++KwfblNQP2krrZFcnL75qo95s6dOzz5lncAnLEPjll469ESm9UOp6FzcL765/VL0jkSwPoDnB5b0/FTTkSKqln2TRsfNn6v//flM7VZeh0tncSKezGsvHGuuv9IQoeDPlmg78etm2p7PUMvLh0M8mbyZJl6v8N9lmiRai/2DeoMUuy4Q/VFkp+j2ndfBZ3nPJvakIOBZiOlUnAs9TQCzdYuwTLe43W9bV/QhtTDzuLgVY3h9aAZ2zO2LwO2L/UCkLN3yBlifYMiYuSTI6499ASLne3JarpuPzOzySrvRZmm/TtVla6EvL0SbT6k+sAp2YOb6uLIZIIQJlmQv3qqgM6EIcVcK2NyljkGxqrfSwNwo6c5E5Q3JRmiKc4bd2WOjDOCmFulfeM0CNCjVc4A3SKj/PhgeiUJ6jyazn9cXOO4b1FWZE1DvDySfKymtEerzzqG14tmbK/TjO1X/v31wvalXgBCGAPJgvSe/q6Jp5/9ENeuXUU1DjcvIiSzMZZ20hB66uRajzs+qz6d99uUoujg4Jmed0j1JnlqufGK3v9KVTpqgCvl73kOtUp5cs7e8hDZIJyVwDYlswafK7WRcbcecJ2pydVsZMxKVeLxZtxuNshlPuqLxCSulSNwiS6A9GxaH9eZKIwS1yuQqmJBh0zYcY4yoh3byxuklMAcDz2Gt/Vzx+NR137Wa7xeNGP7LM3YHumNwvalXgBkWtDIPIPv9N4Bn//UlxOD20fbnMYJ0FF9m1LIDKVlX+11/TN69t3Jhk94UQ2rlICk0eFTHoKoN7141ddkKk3Zg9PpRUASJ6eHQ/ndlDlX4pnWbQd3mNUM06XVfc6nFgZJCUpNk4maXE0BZ6Si6YtGEja9C0nDOfw2w2BLXXtm1SxRt29UbVxPYHLpuDOPpnFJya8ry2365Gn2aj2BDs3mjkXVwXJ9ETRj+7yxzdh+o7F9qRcAgKFgEwnJHXdefpbda3teJzsngmU0+8RvZjb6A/OiWDkY0mfvTnRO6vt6KNyocldQirrNVtQIQ3/Q5PZDYyjcNYS5hYCJO6Kmj2JT+qnfSwAglP/rPtVp1uARE11O3khEA31qQTK57/1FsHluU5qCPQM6BCSQTDkuEsLUNjtlygBEKw6yjZeVZR0kwzb1pNSTrUMpKmhV1ivIy1ylCZO+KpJE1kTWTNaR4SsjeiapDU1NzMybaEtEemUrBprmCjmdjC+wUtwsGCwusBy038iM7RnbF4vtSx0F5CnVdUIzJ6cvc/XqDVS26DRhfS45iyCpdEQaHugYKue1UPASurJuH3wltbmSqpZa5qUzkRpDGVsNYKPk4F2DGILiKjXl0wMnrDNB/bsskQu53LWU/dzeaUgWGpRelWZriSQdjKO5SxBLe7hy7LYPZbBIBr9JUk7DvK2m28o4Il7StzMIpYhYLo4tr9g43leMETNPSx8ZIKNmSJGgBvW62pNLsa2sDuz6yjKJwxxWB+Vnj6Wu8SU+26FEzFhw9X6xs8vh3TsspCHrlhfRMs+2fcUoj9ebZmzP2L4E2L7cC0BZYc0MS5n24IAbj7wL0Q5LxTZads3n4NssFbviuKpXqivtpi21nkukVAOcnNv3cSdSwAt11eJVuQAyTMCkLIe0dOVsZMSUAjXXs4a1jdITOdNbRi241KKNjywwVBrMZmhWshkx+oCrm7EyTcb/6buMSCQt/Ltw1m0VgC5lRByE1Qm1+SIJCIYMNtJqNzUZE3Mq0Gt8s0gq27zGDDmUl1fCMKyozrVSo5r4GEil8chog64lEVIN0pDJczIhhiWLeA2RQw8VtJqBmhAurhTEjO0Z25cB25ffBFSoT3ch7KFRCDlSW65NKyJWAakWmdLSB7U+3LZdd4zU3+uDn8byVgYRkTMrtTd48JroVZWrDrJ6fc1LJK+rvPDgrMnh3BgN7qiqoWo594NjrjKvTu61MnqNBLECwamUVsPpeoOUEvcOn6U9PhqYc30MLhmJCDXlvGZgTm2b4C8DURuch2aG2vqcjc29C7Crw6yeQ2tz8fVz+87VJJGHZ7HelhBykAED00JpSSBbT7N7hbZL7PRePKu3jixKDpuvqouhGdszti8K25dbAyCjKFkyq9PEQw/fgmWgT4aWbj61dsYA8IkkNIRZlxootUDS2dCtsmONhy6t2moBKMX7hJqUDkI6gkBERuaUMHJqcbRVCaktfz3dZ+yapIxgFjzJZgpu1/oilBC3rKA5TLav12jJOZNrMwhz22ogIaLk1PNNX/9v8MmPf5Koxq1b1/ixn/wJoizQZSyqYznOrNRZiT7GIgUO9uTJGFylHW3UVtRfKequiss/IRdQKwQVsqUiBY3RFVOTrJYG5wzSVVGJZWQ6VXeiJRmlJrUek0CfexaN0YQGlSWr0JLZKpKnj+viaMb2jO2Lx/Yl1wCUbAKpp2sVwm5JFMnls76+D4DNVWrwc9QHO1XzzIqt05Ta19Oy9y5V8wfk5VZtUIOHURkMCSH1HKaukpuAydDZx3oj2fpEa1HQqjRUw9VCYR8zsFwYpC7k54SOqRkhn1Vdc/bGE6tVR9/3HK96jo5O+JoPfAUvPP1JQm5J/SnPPn2X3/pVv5m2W3Fy3LI6TbRtx6rvSSmVDFSGrkivhKnazUhEIFXH5cjuNfuymiZSMmqUxfCCo3SG0vWCZS7xFovxtGdrfZajsQSTTCrZsREjm5BJLJfXsT57D93zojPecJqxPWP74rF9yRcASCRyf8L1h/ZZBEVSJpi65GALbOjYU25FAxobvOnDJNoBhmYMZ6ioZzE2gAwPz73rzgBVNQ3loeahYqC4ZDF5eHXuB7W198zJbJm+N/reaHtj1WXa8v/P/uzPkQ1SyWRMuSelMbmnnr+qouAq4FTiG9L1Ey596Fj9sc/wF7//+9hebJNN6Ds46Y45Ouz5xV/8+WGsQhgyEYfxG6RO16STtWeUPKythu6JeHejrl8xzZasdEZKPYecMf0lVVXlabTEtJZ8LShWTSegoELP2L9VG+W0W4GsvNojdf+LoxnbM7YvGtuXegEwWsyEe3c+yWKxD5LLg0uDZBNEkJTR5N18qkOnrvCbq+30U0nVm0SL9Uz7kaYeqM6ykhCiEtGsLkUVqk44D5rIw6rtYXY+TsyjLYY+rznTlHK2IQhf+ZVfiRmE4FUfpSSZZDGyiLevy3mQREyFoAusJulM7KVThk0pka0n96dsbe/x1Oe9ha5tvTVdFu4cvswf+A/+KJYSKXfeX7Y3LI/Zn5aFZiFYnthkJxgPISC5SHflhdF2J1gWutZ7lQ7PdMJgU5uniM+xS4POGNUp5jHZSrAxJd+yDLHOtVaNS8kZscnLJRtkQ0JEF9cQ86QfEcPs4spBz9iesQ0Xj+1L7QNQhe70PvvX3krWMLEgjg/LJJDNPVLec9SKSuV0nnd/k4ZIiGr/LMwWpUQvy5iNkvNU8grDOLEiLQXBMlBqdZtUlcyPT1hxegVSykguERs1GqHaCovr30FUoxQ8iM0zEX2cUwoliiNVkGW/j9pwY2tnj2eff57t7SVd6un7nu3FLncPD2nblu2wDerREWsSmLhkV1VcEbDsaS9hYh+dzvNisSD1RS3ecETWver3ei861DdwE4YGSFkQ1WJzrc47fyZm6uF2cCYzdbC3TuzncWsXa18uSURjPPxF0IztGduXAduXegEwM9LRIbvXb7mUYokgtVKeT4QJSFhXh8+zi57LKMElD2XycKAUd3LnTt0yVvnL5XyxOGoYQ80E7xiUYTQqSnFAGarjGMzwtm91VxslHTHDyKi4EyzpxDZLtfH6uccwtDFsbrSp5gHo2TLf+PVfS3fcsXPtCk8sdrlzeJedhfHuL/4Stnd3x+urYXld+nBGCx5jbfWlYUMj7eFui3SpGghhIr3ZGII4JRFQKcKMFMmpzlOxL0tgsBdXh50WaUzLPGRzL1+yPBTSAnf4ubcw06hwfNqx2N1GcybHV+coez1oxvaM7cuA7Uu9AOT+hBfuv8DuI+/wlS1lb+5cQOWL6ig5VUBshsAND6YkuFhtdVczKib75HLuxKQkbD3cxhZux6tTj7wo4I41vAxcTa72TFVUhThhkGRFLcwwxIKbrqn2Q0lcySViAAiyVi9lGr+sBkk9ZrqKCJ7UU2Kpc8d3/Pu/j//37/89rj38KH/rJ3+Kg5MTFLj7C7/E0csvsHf9IWJcuIqcBRFXW6t04vNjPoflvFWyQz0JRy1DiGOtlqFFIeN8Mn2RjRLkOUmszkTZ78ulKq8SKTL2tB3v1Qg05fdi0xXoS/hh0zSEuCDQkqVB08XBf8b2jO3LgO1L7QNo25a3PP4uQhAQwUL0ehfnFKKqK/m5v1cbpyoabOIw865H1V43FMLKth7rSyAXJrx/dEjGJ1ythMdZSdoJDNEAtevRJmUKMFKPWD9cqzrizusklDVjIa+BAqDve68nb55MM0QVlHtIvaubzmyRr/7Nv5Fv+b3/Hu/58i/jqFuRUmKVMnfu3edf/6Zv4eDwbolh1jPzOYC6MFBlUEwn4W2eGZmS27OnMecw2khrG77p7+daMmSUWglCFEHNzszPdHybNvBaUre+TJrFLkLHWonfC6AZ2+WYGdsXiu1LvQAc3bvPYrHvCdFl5csq/hnK37q9a1MygnHiokITHGxrWZXV81+TNQoNNU/KOUMegXt17wqnx8eE7KFyOReVFldvh5jf0gtUbVSzMpA7czGpRGdUBqz2TGCoK0KJ2qigryBLySUPjQu6ZGtRA5tgqVEPTdNw7dpDPPz4k3zq6adJfT+JhDCee+45vvfP/Fna9oSTk6M151aZlFIyYH1uq/Oyfkh5zUxhdvYllAX6qYQjwpT/hxeFrXPONOJiU93eDIOsyTLDsTkjEmjiNpY6sJ6kZ1+qbxTN2J6xPaWLwvalXgDa/pgUnCmcESarX2gIunTbXfk8CCDA2sOCElZmXvmwUsaLQdUiXaNq2BfHjNF1HU3TYEPf1PF6IoIkQWv6d5GWagOMlMDrjYwAdGaqAPBmz2rrjaQ3y9WGMDbJnt5f7kpZYfHCWkomlAQfDbC38xD9quP44PCMY0u04Uf/5k+Qju9TK0+6k6zEi6v5nNS/6KDiA4MdVZs4zHUyD1frcimWFdZfRudKRqwzwyZpgKxjhcq672YphPryrA1ToptKkSi0vaKSkFdRt/31ohnb47hmbJfndgHYvtQLwMMPvWUtZtdL6NaVLWN0w8ot4okuntY9hlD5niU8qqR8J1O65JONdKNaLB0WMpIUScrQ5adQZbzBGWXhnDjg8X8zQxNYD9L1kLvh9/rpuo6cM/2a1DIeD/g4pu2dhos5aAfAB69ZCAU0uiDZegnbZTQ++iu/zPX9aw5qpVz/mL7r+JEf+REfR61+uCYdlZdGtmILrozrTsDUO6MOEqxkasQIQO7XbZupL3HdTOzGEzLBVeX6qT9aDVsMQ+hh7tfD8TYl5kwH1tHoEpOtMo5z5vQNohnbM7YvA7Zl0/Z2mejO4V2LzXIA1Lrdbl0qqjSNGQ7aDIAbVtSciRVYRYEdVtyy+k5T4Telien1NlfmgLNwynmixjNco343M3Iq0QfmDzeLq3EhLsgpIboh+Rl0jDVDYIxk6K0m0vgLhYnkVMGaUuLw4JSXXnqB5z71CZ7+5K/wp//U93JyuhrmVUS4+fAj/N1/+A+Ii4U7AGMkxFH9nN4POMjrNXxOgzNvtjWGDWG9gbWIDMxXIxuH5xbW53vNLlptp5MaLNWBWTHiv03i1QvVpJo7d26zFVb00vDw/q0HyGOvL83YnrHt9zWd/Dce25daAxCaNSCCOz2CsTbhA5m6mmsBlYYkyR1MEzvo1FtfJZxhe/KHWx1PU1CfB5BNssn2tRV6Yo9Mvbm0kDJvu3mdq9sNdw8Oef7ll/mdH/gyvub976Pve5eginqZpKfXnsXCmca7JY020/F+sldRtI5aYKpKdEJge3vJ/v41rl/bZ2dnB4/v9rFVhlzEgPVHw5i9/kphhuok80kj9YaY15OvaUD1OYiUxCKJWBZyWjcnrM2bjZKeiJDSKCmOYDCy2hn1uUq+m3jQJP45x7Ea44L25BTykouiGdsztkcwXBy2L3UYaNxYnlSVPFGTAWoxLJ+khCfLKDl3qHkUdKIvYFlPj7byey1AlUOps2Hr5XQ36UFSU6YqkqxJdD5Ob+7s0pGRtUVz4qu+7NezEHjpzsuk0IBtcfzCp9l+4m0sLKAkLLm9t+tcnQ4IXdeyWJYaIrgEEsrfGJs1yadKESLCld1tfvwf/Tx/+Qe+n0YTy9BwmlosucR12h17qzvJrrtqJmchNupALyKLJsNbzsZSFtjWrpfL/yl5ZqthYE2R7M4KJtP5ro6zOs1ZJhNrJWVKAzmDSgJG5qlx7znU85VQQhmjO5qm4dQMwsX5AGZsz9iGi8f2pV4A+kYJE3VoXT3ddIyMKnLCkFL1MIo7SYpMAQKpFLoKGDWJwy/isdMi6wDfvP55VI/YrMAxlTbMDOlXnBwe8nM/+9O866m3c//eSQkNWPL/sffmsfZl2V3fZ+19zr33Db+5fr+aq+dut8E2YIyZkcHGETaJEzxg+ANiy1ESEiMROwRsKVEUgRJFIiCSCDuCRAqBJAQloCBFSVBiYjuibdNu91DddFfX1DXXr37Te/fec87eK323kVAAACAASURBVH+svffZ5777qtoR9XsX6W7p6b13h3P22fu7zlnDd63lFbq45v/8v/8R3/NHniAszF8bgmlNfu7wrSCDMJvN0jkdoVvZ/ymrU8KYABQxTcp8oo7oPd/3/T/Ab/s9386rX32e//Kv/jW+8MUvEYLifC6P68cAXBSc1+LPzCM4Em/bWBsaK1GRvGYpUDmYFupCwHlfNLiyttEyIHMP861rncrwlr2KIVWb9CDgcnZquiFsS9E309nh2gYnF9gLgD2299iuN+DisL3TD4BGpTx962FP2vzfNFOymNWafKMxpiBZ5UvVFHTLjIX8hNW8zVMNKQqIc2fiKpmyNtlwKh9iDtRVZvKf+tf/FF/89K8yd5HQd/jG887pGudg4RyHTcvv+I7vQDw4rNBWMz8YNzoqJD+iS8fuwsDp/RVXLl8zgcw+S4k0TUNUQUSRKHjvWRwf8chwi9svv8Sf/okf50//+E/wQ9//L/Ev/iv/Mo8/8+FUOCxfkE8mbmTsHmWALgW66htZdZsQSY1FWsFLLgkw4MSVzM4JW0Os1ICc45icmMgp05XUvDtvTdHMNr+bmBwAXluiOA7C+sznHtbYY3uP7cm+XxC2d/oBUJtOZ5+c6SmefJyli04N2PPM3MyRTWZzrkIYnZjA6NR8yq3wNkdedDNRxYL4mrMse9AWFweI0AXluFFe/cJnafoVs2bGnaEjDo5G4EAaZgdH/Ox/99eZHyzItcA1KnffeYujoyO8m3F6csLi6NC0HgVBOFgc2TmTFlivW9d1RXvMoD46OuK5557jmU/+Jpx2/A9/529zfHBIczjj8PB4axBSQ49IMylnOxnqEuvCSgW7Uk7AkTMr6z3ddoxshudty9TIrcqpCk7MVFbBihvoGJjbFBRrmK3gwflI9C0+dFsO/HDGHtt7bNt3tmziQ8T2Tj8A6pE1HqDQ55xzBcD1U1KLY02nJlnSimL2l8rkBGTu7+aevJuJHMWAGsDqnGhmdDTUnGjf9Pzb3/+DzLoVwbWcdgOHoWXFwOXjY/7SX/9ZToeO41uPcnRw2Sh9IVqSy5Ub5TiXLl0qmZERJcSIb0butF2Wx0kWDJKwQdSOEAPaK5/4xCcYhsGoelcGXNMYk6BpjGmhRgtUQgnOCYpTXwWxsj2cfkWrYujdVFMKMQFYHf0wMJu/O+xGgcrrz+T/ephgguKLRq2Mrg6X6r7U7BHnHIftAX1cvus8HtbYY9vGHtvT8TCw/c/FA6BQq1TJSRDZGs7CIyIjTU5GjUn1bEAsjzG4ksCscI5itXUUoc3aEudrZseu5e4wsPYzDsMSdbA6FC7NrvIX/4u/zJVHLvPB64/g54c0rVWIahpvglZ4wrlCoyup8hNGBtZ1yWhrsWA4xmhJPbGl6zqaeVOOZY2vddSydEPTjFaxsPEzqNwWk5tGKSKGCeQGq8Rqqdvn2tlGsFLNLTEep9aM30VLKntgv1O5FNRNXRwDgviGgAXrMuDFLejDxQWB89hje4/t8/fAfr+f2N7pPICTfq0MgaBjJbxNv2gtQMVvZ3X2LNBPLMWvNpkSjlCq9OVR07Zq7WjTn1eO4cb5ZNpavaYhBP7p577Axz7yYe4vT/h93/TN3Lx5k6CR//iv/CUOLl3hxiOPcenKMe3sGFzd3m/kEdemb86czP5Xj7BYNJyuhzNzngA2miBMWBw61kapA2qbLglxA6rGx/beo4Vv7ok6kKSASVXHaqhqSewhHWPUXmOl3aaX3FhhUsQac9i8KK+pVkJC1nAb841rnzRWu0F6TYFUb6UD1qfK8uQ5bt382LuI4Ps39tjeYzuvw0Vi+5+DB4BdbF9N0xYraSZpIT2j/87qlG+5dtn0nSWwOXs9+0vPGxPtIZ23yYDV3CpuKiSljsjQ060H7t5/g7Bc886bb3Dt1tPQOK5fvw5NS9vMca4CTzLzhyFtdLsoGqGqTgJ12W0wub40jUHH9zL3OV9PaTmXwN0PgvPCrMnVIjdYDaqTG5LQkhNTNtdq1GpjmaO9aQG88wpWZTreGPycvh+jVjfGNLeUtFMKi4Vcw2Uo880/3nvWvbJ666s8+uTHL/ABsMf2HtvT9x82tnfeBRTEoajV1d7gH4sIjjEBIxQTLp7RiGAETUzBpPNqcmxjQMDUX1o0q/zHOQJWjhNhPvdcnj+GHyKXbzxqdVe8+ScF+20+UC2mp1Po1oH5fD72JVVPPzyg8fMKSNsBF4XiMx3N4VwyOJXFZUxbb9uk6SUKWr5uMP+r2aJK161ZzI8sCObG9H8rtVubvTEvD9kE9q4hDMp5XQzLzS5rhZEiDNZvVXACjTf/dIwminWFyoyJ7DrxmhiJGhGERhpic7Hw32N7j+2LxvZOZwJvjroAVq446KQt2XuTkZIoIC9OdRwFF3RSD6UGeF7gyeHexVmXMys3NaQ8VK1YlDaOBS3etfj5gmZxwEw8DknXlecUacQVza8UBIuaaoOsmfvFOLdUnTFnJeasz1z1cdNvOQFxKqlbtJqUWVlXQRQRTk9PUQJOeoQOj0NS+8JsqjuF1foU30x7zlYTJerUlN82zs7ZhCNG2wffAB76OJrJeV9z7ZsoVnky3zjzCGLN2MUNOHd47hwe9thje4/ti8D2TlsAtVa0ubCZ7qZY1t6kV2lqjnHmeLnNHQGVKlCmTD+f+MHI2PDhPPM5RvPK5ncz2GqzNTM7RATErqPxjWl2DsLQs5jPEkgt4zFoKMeZHcwJUXEi9H1fzqsxolS+Wq9ojEiuqFhpRvXYDHLZZ5uzwpPf7wcO5wt0COA9Gq2/q72t4MQ43MDR4qgyh/N6uvKvxshAl3zBX5/+YfNSIJvHyYfs8h5Q9ki9NdhwMftRBUQIElNLwowTh5tdXCmIPbb32B7ne3HY3nkLINdH2Qzc1GNTmJCYtJ9kZlUCUf/vokOCFI2raDobZW3PHJ/t2sdk3lvMVlU1U8473nzzzZLAcbA4SufMVMBUS71p8K5NWk9Vc4WICJyslvRxIARrTh17a8IRQkjagv3kUZv4MUbzJQZAG5SeEK3OSk5xzxqQmZ/mk4wx0seAiEdVioaU/bYi03XJtV/A0Q9r2ra1hiPnmPV5Dc68LKm5uWE+7cv4d54f6nGusTr04kdGjYKGSAwhaVyR1ep0+xwe0thje4/tPPeLwvZOWwAwpqHnkRM56gp82RcpUoFV3fiUzoCvfafqUhAIe5xWWlLNkshAPk9LOs803mQpZH+dinGxH3/8cZtzMknF2TUFAjEa5U17Uwdy4ke+PukHrty4xCPXb3Lr1nX+4c//Io33RATXNkiIpdysiGdIft8YI+v1mvnctAPT3JTUzhvnkpnpRrpb1lAi3m4oMjDzDXHo6QarHx9jRBqPT1qoiJnM6sYSwzFa+V3rySpEIk5GTSy/lxkR9Rxsja2SYl7SzKQYc2LMZ+pUURU8rlAHo9g6qioNYr7SZsZiMboaLmLssb3H9kVje6ctANWAips0z8k+zGxC1hrO+EVHFIGcMJPMtKI1pP+DOkISlrF/aQ2OPI/tgrB9zjr5XeatQByFOvs+67rn2bQWcSXI03VdmUvORFzHFY/ceJy2mfEnf+RHefvu27z0wlf40K1H+M//0/+Itm0RsbrisbqOpmlMQMJY0jf7QkMIVs0xRkIYyhqVxCOJqA9l7YcYODg4ADQ11B5vXDoYdU51FDglmECF0aWRNTGgsCMaP5Yxzu358qh9omPiVPpfkvbnIpFAdFZnPmNnc1/s5ndx9YD22N5jexewvdM00PvrEy0ut6K5+HHhVc2MBPPnTdrnTbyX6ddIictmcv5uETqmPtl83rzh2wI8mzS1bbVANAw0TUPIU1Jf5rN53hhS4MwLOozCG2Pk5OSUT//jT/Gv/diPEtVBVK48cszq7bv8ky8+C61pkU4aMgti2ZlmlIXBKZycLGmcZ7U+wSm0B0fG2PBzIBLimplvTH9KWam15pLn671LGsyogUYXUuli03ZCUKJ2ECIHBwd0Q0puKj03ptpSrTXlPajXZ9M/am/aNosarTCQbjohEBRitOQihxhNzwn379/l1tVHzo/YvY9jj+09tvMe1OvzsLG90xYAnAVlBm2tZYzZepI0jHxZWVNKI0XuM4MgSEhP1aQtlXOc9X/WwqKhSk1PgbkYx8y7LEzZdwhYxp6OQbMXXvwSUPsRKz9mQkGIPeotycQE2TSdJ59+gpDYGb0Gvvrlf8r/+A/+Z37yJ3+SO3fuoNKg1fVkzYhgpcNWqxUS1vybP/YnePYzn0bDCa+9/gJvvfUWy/u3WfcdgqerW/dJCs6RE2M0+SytsUauWxOFUh8d8g0g+VvFs+zWZF/2mZHnPNmLcd1tbaZfcfVWV3tcDpmwkIV4Emx9F7bG+z/22N5j++KxvdMxgCgU0zKxYcuTsk/kXhe9BUiSsJhbbztTIr82edIDnrSR5Cfx1E9Y+zxVFeerTdDUU7Tuv5q0ptok26wu+PTTHyraVC7wlP2DGWQeIYZI14VK8OHBckUjM7pBcTgOD6/zu3/n7+JTv/I5PvLk07zzYElsTW3I/Gp1yefcD3Rxze//Xb+X05M1P/8LP4aIcLg4IKLcfOQaf+JP/jDf+R2/nyee+QiBxkx8Tb7G6JCKkxxjBO/KOk1WO2k5Q98n37ZlMobY43x7Rrs8s1uVpgpnBQQSy0Uz/x3UOaIqtYfd9i9pohLBNYh4Yjz/3O/32GN7j+3690Vhe6ctAFtjR864g7OsB+fMJ2r5Jak5NtH8odJvfRK66EqmpMXJpj60bZpRHjl4BuPTPwN/9N2NyzoxH2M8c478evYxxph8toza02ze4LxiXaSExeGc2UGD8xHnI+1hSxyUj374Q7x6b0kQV24uRZuMio/wYHnKnbdvg7a2Nikod3JywvLklJdfep2/+Bf+Et/5L3wPD07v0/c9wzBUwboqCzLNc3RHbB81MyKnyWv2Vxc/dVq7asslVkk4E/M8/yiDjnhQxSiUEkBbc0UQqbM5S5at5j68FzP22N5jexewvdMPAMhPxgi4CfgacTiFQVPXHC/F3C0BIm0ni5uTZtTlBtPT3qb1OC84Nmo+9pO1tlojerfftQBmczprVJvBuc3zRjegznH96uMsT63f6RADYd3xuS88y50HD2jFkm08UkzjrClFMRre1Ss3+Jn/+mc4Pj7EN45MeXPOMcSero+0fsYLL32NEDvExTLXqD3KgHMQwzRouZnNOt1HV8z9GK0EAK6ffEacok7z/edMNmuMKVsSkom+RRNODc2t0FjAim5tg3mawwWOPbbH//fYvhhs7/wDYHPhrTunMEQhJkKUw7IDxSnOa1mgzad3dBZBj9rjvOLUTTLrzhvnCQycDeJkwIgEUL9dS9swmbvubO3u/L1hGMyH61qc2s2hPZzx3/+d/5br16/TOI96x6VDbwEgKs3Ou0lBMOccR0dHzA+OeOYjH+Kv/ld/jZ/+d3+cj3/iI/i2IaKIQusdDD3/09/6W/QxJQxJIMRxniGuEBcRLCBXBxHPUu0o1xujlQG2eil+q79UnBZK3eY+2BpvBMnqtU3a8jiyRjseY/rexY09tvfYrvfhIrC90w+AkQMtqAZy8SMz7QKOnpCDMxuUKDBz2bZ+mvwiNGgY/ZpOwVdP5SBMam/k427TXFRDMcNqTUfTk3pT+wHONHRomoa+7ycVF7MZ2TaLsvFZozrwnqc+8HF++bO/wuFRy8IveO2d+0YN42wp3eDG+YsIrfdoL3zwgx/kt/2+7+TP/fRPcXz5mDu33+Dg0hER5fj4Mt/3A3+YmZsX5sbEF6pteT2XK/CADGOKPerou0BOwfeuJXdVEs7yzzf/HwVFTSArf6kIxfcJ9j8oAwPqYyUs2c0ColjiVTKxt3VXelhjj+09tncB2ztNAz3p15ovRHXcIIeUjc+b55FSKnccimM0TzVl+zmxII2vntDZhykKkWDJKjTlKZ7PBWf9p7V2UIpaVeP555/nmQ99kK7rWLSzM9dZ+07zsXPQ7PT0lFl7MJljprydnN7j5Zdf5nf+9m/lrTfewC2uFt5yNotVFRkipFriQwJWGJTV6Smqyv3791mdvso7t0/5R3/v7/Ldf/SPcXx8mZs3b9IuLiXudfb3GlhzzfamaYrvM99kjMPuRt+nyy3uNGk4Y4DQuZHZkANrm0OQsq15rSxzU/FeJhqTVP1TTSuz/+uSuVmLe/vtN3n60ScvhAq0x/Ye23Dx2N7tB8BwokOfQTilT0ECQFN16MHjNGfH2UbZ//a+NYDQor2gvrRcAyA1qI6JlbCtFV89h82AWv23j/Z3yOyvDYGaz+es1+ut75WhxkO2YJSNDLAYI2EYWRgTEzVpeJYqn7XMVKwqlRPO6fJZW+iHlc2nD8WcbpoGbVwyvxmPX2lc3s1wbVOuwVfsjMyz3nR12HchJwWVdSs9WXW6X2D7lD+rpiltmsoiQBwLcuWbSVo5VLUItary5puv84HHn76YB8Ae23ts7wC2d5oGakWcspYUzggLAGGkW41FsIScGl+72uqmDYDVVNHaxBZIlf8shT0DIrMEpu3g7DvbTb3gsuk2/UzewHv37jGfz1G1RhXDYGyJGlClD2pF8XPOwmAqEe91wsQYJ9cDrmiDWaNx0hZ/sGkn4zGbpmE+O2SaNbqmiS0xzKGxTM02Gt0tV0UUsYCcS1pSQFFpiGGNiIOqe1OZHt5uAKmbVVmXnDOTbjRGQUyCAWhUmiZpRWI3gDpxRtU+txlwzP83jZUS8E44jY6Ddwnsve9jj+09tncA2zsdA4DqySgeGJ/QtWkJCeipUJalxW87mAXQ6hK6qlZullCZ0xvHzr622jzOYC71Tqqnff499a1map35VWezWTl2CJb1+W5Mg3rk+WeQFlCk6/vD3/WHcEGJ2tv1puChMpS1cdjrmVrmvOIbO2bWJO6e9pbdOXRIVJb3BvNXugi5FypTP7VTM1WdmwrvhBMtEWSo1goEt2Xdz96EQjBhiMG+mxkreZS5qLeMTcaAZAiB6IQgjlaV4C8W/ntsnx17bD9cbO+2C6hf61l+8TQIVP5OF5z9pXXCSz1UDTD1yFrReRqPjToos9F/dSPpY1sSSP1a9jNOeNRDb/U7XKU1VOa3qrWEK8CcOAfteobUsCLXgc8mqtAA5jrI9U9iDExwrCOH2Mz8wTLQZ6YVSdLitHGFvdE0TSXs440hxji5SRlFb7o+drL0musRnaGYxpjNZefPdyGYmWyaUr0GTsdrsLmY2ZyrbkanuLYhLIXTBy/w2KMX1xJyj+09tvOx6/Ewsb3TFsB0YaxV3jafZf35bYyJsmiJMeGit2SZVGyrHlMtrKZZueqHM9/ZnMdmFH7ix9SztVea2XxS3Kk2H4vApPln7SfPRaNDo8OXUsE2YioHbMewz+XiYLP5NLuzsAmS1hQbB62HPkAfWC2XFpyMxt7ISTjbfMVASZ8PJI01jJzxEiCTyJ27t0E9Q+jKmjlPMpHPd0eYnFVYSHuZtaQciBNmZQ9NWBxNMM63bNwsH+bYY3uP7V3A9m7HABif9CMtqqbPWSlX1bE2uIiwyb/N9CynpmWoyz1Bkw82juaeQvWE3/58rEEMbPVVHh4eWl0SyfPKJttgfkbfTgBWm9r5HOV6Ns5btCWxZJNQWCT5OtN1u1Hz64PiU7uhRozC5lxTqHVUtLPMXohBTb9ywtHxMRqUTgKtd7TOI2rc7W3tByWqleEVMeZJFTCrNcZr166N5j6eMJiQms948+aT/bojO6K+VtMIx7K6xdcaW2JmvAiIE6J2OHeWtfIwxx7be2yXY14Qtnf8AeCA6ZPMglZiZDYxVIsk8yhv1ka9FBEpbeRIfwujb68IRwq21N+rzdLa1KuDZ1nrqTWa5XKZ3p8KmnMNU5N7agpvjvq1LExgwaf83qwxil7xHaZuT2FIBcRcpEGRvkNmDSEOtjyioOY/zHKer8G5bKY6JAmwzhvaaGCPgHf+XK0UBGlAw1RAalM6/z9e24BvPFnY6+u2PTBqXD3MBAeiSxJwlv5YH6feJ9deXDnoPbb32K4/c1HY3mkX0HnZbKYVmU/UeZ2UXtW0iXXXJFWdbOZmzRWP0CQwn91sm8eG27ME7uzv6cZnQdmmPW0G1WptKAvhuJF9Kj2bTMCaRaFjwK7vjDZnzAslBjEanfaW4dgbyyF6M9/X67URDfqq1WB1zFkFi5yhGcSjVXa7YP7MzeBefTPxMWlR6TN1JqOqFo51/snrpVGmDbjLOUftyNY4n5PEKglnrsVuZtG40qkD1yBKf7rCb2mu/vDGHtt7bNfnvBhs7/QDYLtP1PylJSU7xNKhJ/sAMyXOUukrZkROo5fpgoJtbhS4d/LgXc+Z51ULkOr2rEjrcVr7Ws8fOZW8FjZwOB/o+uUZvnQIVpc8Bil0uAcPHnB6ekoIwYJZnUK3Yh3UmkUPERcyj9vT61QLFBFrbJG0LoDoGro4nSdgLAvxk7XY1HwGjZObkTIQYndGqzyz2slPemZUQpHN4VIDZ8txynnTe9mv2/SRGFdWPfGCxh7be2xPxgVhe6ddQIFkzlZP3ihiuk/a1NzUB9KTW4FUDKtsUPGHipm1iaObF29IfF6vwqXDo61zUVXatqXrVsWUjpHiKwxbHqW2KeUIlbkXz2oAWzQncPT9ONfanNYoRA2lomGMkcM5rB4sWXqP946og2U66gNWqxU3rl4zkDQNMQ44UYbe40NAmgGnh3ShK2Dy3hqI52QZ882mVoKuNc1Rk1bqmZjDwBggS4Er0Ya2cSY8MY5a0cYNpnY3nBcYdSXIlYJ1WYCCoOpQOqBaZ03r3jr6tdDOG+DiWkLusb3H9i5ge6cfAC5aQ+f6iaoxBXI2Fy9ExI3eUa0oZ9lvavW11YrqqZJZEo2MT/h365G6Wq0m5rL9nbkJNaNiE+yUudQbv02z2vyuAXr094UQ0EFYdWtiZwJyenqfIXS8uR44WBwRdGC9XtO2c9rURUmdcPf0AQcHB0QNzMWbv7i1apNKi8qQtA8TkDr1PyfexGrOpo3anSJualIbl6Wq4IRBrUxBEKszf95a1+uSMyPzzUXEiqUBKElA8o1SB6LG9IIr+zIGV4V19wAvkXiB8N9je4/tvM4Xie2dfgCEuJ4Ep8yXaBqQKjhn6fG5ymoNOolaBEVKZ4WNDSmZgUzOcd7GZaHYPuz1YbD2eOcd4+t9PQtG9pcKcwYGZquBN+/fxiGsu4G7d++iMXLv3j3+1T/+w8xnl1gQOTg+4mvPv8h/8B/++3zv934fX/jaizz55JPIEJnP58wS37uuhV6fuxbmnFkJoNEn/6YHgrEbYleE2SlWqTGb05XmVLTSKDjnz71JnJ0P4zzOGS56kB5l+/4FMU27UXAxZahuBGEf5thje49tmw/jPM4Z7ye2dzoR7MFqqeLdREsYA0uVrzSNrA0U+pSkmh2lO05mEqj9nU0tTSYlrrSjm6yLOpChaA0+c47VoQ2MT2ObTwzgG+W9QiwiUgQ3szw2g24w+lBXD+6zWq3oVj1vvvhF/vxP/hR+ueb+/ROCCLf7Hok90BDFocFocG3jWCwOmc3n/I2//Te5dPUaV6/fBCdIYlw03hgkluYvI4Bdk25GqQCVWFDRe18oh8WsxRN1mIA5lyTOf9ty2gshBEth3xQUFcSNe+2cVDcynRwL0s2RWEr+5j1Mqwc4RJNZ7jx33niRg6MZAwfcvHJju5S+z2OPbRt7bF8stnc6CKyc7Xo0CksghDF079zYD7VmRYybNPb1dMRRQLD3nLQEnT7NczZf1CFpDikg5MXCX2IbkLUKDebT9E1+UtdNGc4GzFQVlVFA8mvleKqEfsAh/Mov/bIJyumSH/y+7+MHv/9PsLr9Dndvv8M6BG4v+yJYB84xV2hIzIAh0vc9d955hz/2Q3+EoV/z4HRJjFlDcvRhIDhKIkvuheqIEMd19khhOJS10lRKQDpcVWrYTYCd9qVqsTfxv07WpdZ4t5cqtqMGa5AtQkzHt5ycah+jQqr73jhHHAKeNTE43AV2BNtje4/tXcD2Tj8A1ssHZzjK55lVMcbSZi2PXE89MyjKZyVtYC6cpaBDANeU92EUDhvTbEnXWLXF8n4U05WSRmN+vTzvLCDnL/e2m4FD8KLEoeO3/ubfwoPTU/74D/wQ4c4D2vmC0z7QiXBvdcpSB05D4BTPgy7wQAP3cdyJygkd99drRJRZ5zl98x0aXXJ6csK6W6J0pViXiNHpcq3zPJeoA5qSXmyuDqfJf00wdJaG1TpWm1RwscXFtuzTe117qZJYXBhSjinenKIBQHPTlGDnUfAyUgpFhNAI0Yv5aFG6bsXBrMX7GT5enAd0j+09tncB2zv9AHj1lRcqU2kMQNVjc9EljhtUXsuMivS0Rj19WvwYLHijTlJ6uUNcQ9ApdxnGCH7X5dTucU5Bo/Urrc45zs8RoysaUKa6xRgRjWgYX1M1U09DEvoo9B3cvXuXsHrAvbduc3sIDEPHO+uBQYXBt6VSoFeYOeEGcEUCPg642BBCoAsD9Et+5I/9Ue4vLZPTOSyYhsdtBK6cgpPGfpyZxtnvOcTIuu+N15w0GqeSNBxKqnxwEP2a6NeAFn51zRapz2l/55/abZA01DogJ5iLA8dYE75jdFtEKwGslO/G9QnRzewMF+L8sbHH9h7bu4DtnX4AHBzOidpVvtHzr6pe6PKU3HxPYtF8vHgIIaXZ249LAThJZlY+zpQDHGkat2VjN4dtkijIYCZ2Ttyog1AxMT8y0LIgOudKg4uuW5p/tGs47d9BdUDaGfNGWLYRUYeLpr006mlarI2ezGjFMiVdUDrxLBYLjsPa+o86K9wVB2XVW0u81WqFquIbMe0SIYTx+ovWKrF8Zrlcok5KOd7az6xqfurSAk/G/qphkEqzevchkvzbRUpGQdos22comwAAIABJREFUklXvS6bjeQeijm71APUXz33YY3uP7TwuEts7/QC4dvkmp/duo7qlbVs1JgIiW4RJHaQeqT5VT5EYx6xJieZzk4Hsl8vc33HU2pgrPtNz/Z9lwyJRpoGbnGoP9qRe990EVCpY0MdbUGmxWHDjxg0Ojmf8xL/351Dn6Rk4Plxw2M653C449oEbhy1XJLAMHQOelRMQzw0/4+ZRw+XGc00D3/Zdf4B2PrMAWdOwXA0cLQ4BmLUL02SCrVsfB6TF6qtIgzSZSjiC9ODggDCMCTC5JjokDTJEXKpHb2yXXDArF/4afdq+8N623xAtOUZLkkyQgPppGeN8vByIdFj2ZQg9i3kL0qbGKF9fssz7MfbY3mN7c1wEtnf6AeDaBffefh0X+wIir/azbahqWmRG2lZ+wjtrGRfMq2d+NokgZo46TXQrhLqS4gjuqalsDTYyO6JmDITyukXotSyyHauZfB5IvOQe1YBXM53ziASQyP0Hd2lbz2/91t8MTvkLP/1n+Jbf9AH+3E//JOo7/sD3fBciyqMffpL1ySlXn7zB7/nt34prG1648wY3n3iG1956g+bagh/5iR/H+pjOcK6haR39sEKxTFPfZJB6PA4XPe3MW2NyNeBLBKc51R3ERYYUT9M0ZySg0SemQzZzY0m136xYmU3r6brnYXOKMv6YrPrSPWrbEBHEOyJCWJ2gTWq4ru9OvXu/xx7be2yP4+KwffG28LsMEeHy1RushzWz2QxVCJo40Bvm0Bn/qVBMqqgDhClvN38PQHOlwfS6w/yVWYvygHX5Ma3H0sSzqTyee7FYlEJZPmUEdiRTLSXsjIW2JGkpLc8//zyPP/64za1snJnYjXrWKcV8Nlvw1Ac/yS996hd56aUX+Og3fRunp6c89eEP8X/97z/HH/yD30mMkV979vP86I/9G8wPLvMLv/IrfPjRW/zZn/53WFy5zuVHbjGbX2Ixn5vZGxJjIQG+yKcEEEWSdpoDaZrqn0i+KZRlF3yT3AyVuY+sLClFwJXjDGUNolqVw02O+rifSqYlbmpOMQmnOWftGMNgx87LmNvtxaic3HmZ4+uPEPRitX/YY3uPbdudi8b2TlsAgzraecuDu2+hg+Iyda3mEUtEndrT1VdVC+PZwlgMpglZZH3gzJAAag0hVBo8QutyOnYO7DhUA13X5RmQTd/l8qT8D5TgUh4mzJZo4qLiohK7nqcff8K0PxmvLwMxH+fKlSt41+KbGX0Qbj76NNdvPIpvHd0rr3PVN3z39/4h/vRP/TR/9qf+PPMbT/KF557jZ/+bv8FsdZ8/86P/Fu7SAvEtMmvow4qm8ZbYIjCEtZURcCOrxISiQaVhPayNmBY6W7+t7orxOs01YVqQ0qE61oPJ7g4nDZlmZ190E7+pCU3SpjYEJGu2haaXzGQTjrNui3Vc4Y6PUOcTjiKJ6H4hY4/tPbZ3Ads7nQh2+8E9jUPgta99nqc+9C1WzCnGiZDkYJKPDslt0Py0xV09XDKtRDxBuuTXs8Vy9BClFFJSZynlJdsv5uARFYUv83JtE8fzBvCOefREVTo13ncTIXgLaPUxoAIO4yRHKFqHcw6GANowSGC17Lh85FktrTjWMFhK/IMHD/ju7/hd/C9//+9y+fgK/+s/+Pv88R/+EV556WWaS5cJccnpck3bD1x58ilc0zKfe+bzA4QF0kZzLaixIAKa2BFWpsC7RQryTRt55FFoh2mIcqZ2jJBS9rNwbQTH6u5Nm+c4SyGMpSCaAuQgnC7LvuTv5ZuUiHDv7VeZzR3Oz0HnqFN0CFy/ejGJYHts77G9C9je6QfAWyf31AWlX95hPr9CczhDxDMMQ9m0IjDaEF0s9U7y4tbZep7UnCIJRXShCImIIDoU8xis5GsG7Zi+bt8538eWAkQhaWHpKR69lgbWMPro+j4kCpoBo+u6QknLx3MhXat2DL0nuFCods45lvfvEWOkX5vQr1f3aQ+v0orjB77rD/BX/8p/xke+/bexXgVoPbPZjLZtk3nsk8aSsg3Tuom3hhIZZHFY4qUhunxDyZmm/gyfvXDNQ06+aYp7IAchy2ptrGPe0zIPkYkQTipHCmO/25DnP/rTRQQam/8rL36R69ceQVwLOsN528+rl69dyANgj2073h7b4/sXge2djgEAeBHibM7rbz7PE898AhFb2NJiLfs+ZbCnfYg4kSlNLi14wOhhkWBhl9w8I2fkiQW1rPkzEy5tNv3sUOYftfR5X+qomKlm2pDz00xAK/TVpOJPo6bXChYYSzS2WpDyCA7zA/oZIpFWWjtHSAyB2QFAqtMSaGfW1q7xR3zs276Vj3z7bycQaA7m5kdURxyUL3/lM3zgo9+MbxvTNpzksij4PtDMWoZUIqBxi5KQoqrEhPQoVoBMVMcgF7Z+CMiG2Zp9sSKmcWaBEBE8gsbK560OJRKcGOUwKuqFqJYFSkhsF1WckL6bzpPOH1AYeg4OD3F4FAcyoOrRcLHKzx7be2xfNLZ32wK4d0czqN585Vkee+obado5cDYyXvcptcCOZedpCqxlzanWmvJx3o2DDRUwiqako3Bq4g2n6TxYLzk4OOBsIKbOnARJWX0xDhua3Vnty6XNzOanj5TEGuccXWIw5CCRdvb73v07HF++yoNuxbxdMPMtwzCwWCyKuenbxcQkLRpJal0nGzpCFFuzJn1QaIpw5FEYK66ZuCsmzU2q/78exoJzAqnlYKmTE7XKWD3rG/XeE6TljZe+xI0b14heaGKDdboybezGtesXYwHssW3f3GP7QrG900FgG9aw4tbNp+mXJ0U4Mnc6g3cEejbLRh+pRNu0nE6fMyonvr/6jDr1/aHGsK7rhIAFZZw3cAVn3XhyDZC6q9K2oRp45523aZoZmVaX/a6io9AB1u3IGfvCa2QQRRuHNo7oLZgnIsxmM5qmoZ15fCNcvXoVR+T+m68yd2YWLxZWJzwAuHYMOGE+yBxcjHjuna5GH3EVgPSMjcFVNXGX3UTYJiWL02slECYR57f7Qc9ZrclxYuK5h0rjzD/5c604vIJ2PcJgJX/1gExVDGo9YC927LG9x/bFYnvnLYD8dwxrXn3pizz9kd/IrLmM0k80pXqBRkZDavxQqHDbF6X4XHOQKqbH95ZFzI2v7Vw15coV0xUguDGAJiLMZFqLPWs8GXw+JtaH5GBbDZ7xHHaMOL6u82qekaH3NKQ5NqmhhbTlZnL37h2uXb9CqYTIyIpwzpGbcqszMGahz0Ny8omr1kYdstFA28rsnr1JZJOYZK6+t4ZkWaxZO3POFd9ovjmawE5vnln4br/xKrO50CyOEBbj2g2mZd688ciFWQD57z22YY/ti8H2zscASAvkveeJJ55gWN6nvXQw/cTEZHaopghXCppsCsdmCdc6qGYvbABHSbVQBJxDdF0FdEbwn5yccHR0VP63JBj7exBNbC+b63rd07bt2DnIKYIzv20ccE4qYZk2nh4bS3uQmK63BYGmVXz0rPqO+WyRzPmA4Gjblhu3btm1Omd1ZUpAbLx2jdEoheLI1RKdpCbTLpofNHpUUsYjSVtK3mnNc8+AzHQ4iUD2W783V9n2w7ogCYqoIihRx2zUzLvON8TyXefo+56T03scX3qUqG2hO4YQwHlWq9V7zuH9HXts77F9sdjeaReQRdetMl8jM3x7mVdeeWWiQZzNkkvBF6dI44tA1OZYbQZPNK0wFtCqn/jBYWAUywJ0bnxujprPwMHieKoJlaf3aMblMZ/PJ5tasyPs+I4QdKL9nT8csepqHRzMDxZlfs651Is00oiZ1Z6Utr6xFlY0zI8888R3HjTauqQ1Cs60uimPWcktCe3frClZRinajHVT0vsxEy6qa6z3SjWiSesTjFs9vWFMv5M1pBjh1dde5Oq1A7uBMGqkAGG9IqxP32Nd37+xx/Ye27uA7d22ACQSU3efXgfEtTxy8wrad9BaEKZOnY9IRfeKlZaR3t+gdMGAkzkxGi+YJiVcpCj8pglXziVS6F/j5jq6/oTDZmE5lZm3TZxkacY4+kNHcNn3LcA3lnwtGX/pFNl3WpvY5/kZJ1Szutqk1oAe5x+x6bjYohosacbOOtGARg1yDHBFUbspOYePs9GIL5/JLoM8r6yejmtcX0s2f62WjYNgWiQuMoQAVbAy6zCb1nYIPT72+Nn1lA2bjhmFEJRugA8+c3Pr2j2Uscc2sMf2RWN7py2AEDvrhxrNJxkQDg6u8Dd/5j9BQsRFRb1jQAlp/0vgSwWJUgWBEhgmWlUDEkYQh1iYFNkvB2cDZ1lzmdZytwQUykYPkOqm2GHGDbXjjnVWyjHUBMGLS4keLSK+aFDaOGhrbcp+twLzlCCUi1E5Z40vcnDPMhN9WdcYIxodGp0FAlPwMMbEF8cT1J3RGMt3JmspRHUM/UbDkk2anFNyslG9lnk4NY3YS5z4b60ZCkhwpQNWbpqS69NkIRMXUBW+9vobXL1y3fy+bqj2AeLQs9A1D+QSFzX22N5jexewvdNB4NfvvKYamylDQQOru68wP7jM7OgaXluirtDYWgacjOZQforWYK5NpfPGpvahqnjXEqPinBBd2pQ4+uvGJtNjWv224RNPOPpRuwIK/WtzrudpQfkaNq+l7/szwa36O0GlXIdUlRtLI+pJsBG7SclYzyRrcXVlSu8dooGIw/tmEiCbXFMuOZADe7EF15em3EX4CcVELxpTDNZApDAipv1e8xyda+i6jtdf+SqP3nqscLqzsdv3PcvlksdvXuf+8pBHr31dVI1/5mOP7T22dwHbO20BSNOUrMCyeXiOLz3KK6+9zDAMVsXPzUqruvy5SfZejBsNos13uQkwM3tHClh9vKgDSEjFtyI++Q9rzSQ30lAV03YmCoGdcxBlEK00p+m5R+0KLPPPvnd4cMDRwcEExJu+xZxos+0mkAXOYTznIiDqi9ajpopYYCtOhaWwSZKq4ZFSdVDEEVNKfKbClWqULpnjuQhZ0s5KpcQ4FRBbKU8MgoS+1LYRHXFQX59XrPZM+n4YlLdeeZlrVw8JE76jCZbXyMwpLA65+85zZ9bpYY09tvfY3gVs7/QDYL0+RNyQnspW7lYFBj/j8ccf5+5brxBDxXQgLRo1gCK5bkZeqBFg0/rlZ03ZcWwCz9rIjanbWXvwak0qgosEFwu/mcT5zpF6M0dDESYXtWy4FiqY/WiA5f0T7p+cFKBtAibGyEx8Sa0v86y4zpvJPiaYUy1IQxUEHKzTkjrzWWb+M4BrrX66nSNriO+ucNQUNnshjmZziMbKCKG4RoJ4Im5yjfmmkceAEl3W1lr6vieyRGZHKUA27mkIga5bcfPx67z2tfW5GujDGHts77G9C9je6QeAdyuuXX+STtZsZja3/hrCihDv0kdnPVLhjJlJWuQQQmIewLhw03rnLug0SWUjIr8pKJuLfHh4SHS+mGaq5r8Nle8QTKBaGlywiH4U2+xeY/H31tqSytkiVHV2aIn+OxI/eiBzuuvrANMyrc64rY1pMUMlQEmIBfCpgbZqYj3kRKCUpBRAaEeNB874Qes51kK9qe3kBJ1Y1lRxBFzlA928ljyccxCVYeh447XnuHb9VprTlJ0SY4S4Zu2O6VYv0MrFcSD22N5jexewvdMPAIk9r732OmHNpP8lwOAily4/xitfe5EYU53yxmqSu+SrtKbNZ01P05RMS6rb2cWmtydzMduqXqYiZza6zDP9u16vTfsokaV6eadPeOsnKgQ3EFKhLocxPzTEDa3GrsHFgItT/2CM0dryDXW2oOO8rY2ay+KOApRdEXZgcz3oML4mMQW4ZJhoVBb4Gkqj681RBxhrWt40Q3PsgGR12oNpn0XYpuUM8hrVzVNUldg6utWa44MGmrPBRLtJBm49/TRvvnKHXh3rOuHnIY89tvfY3gVs7/QDAODgYODKlUcRN5hGQz8+NWfHHF8+4u5br5l5qQqeZFoFVEzryP49A5FMfJSjGSmgTeEc58/m746BMNLnqyd+etnPLCtRWknBPa0+n4NnI4VONSDq7EcE13h6jeDG4M9oIsIQTcRsLrnxtglccHXwLEwEuv4pAM9ClrShnNDiEzWORPULqan4SItL5rKOvtV8I1HVSSZjraFoFEQ8Id14Bg3oMG1O4qJHwghqjQ1DLwXgqkrE2DH53A2CF0foB1752leZL44RzaUKshZse+5Zc/90jl+/QyOO9en61w/If4Zjj+09ti8a2zv9AFBV4uA5Xd7lxvXHCLJCYzZBDbzHh7e4d/dr9N19YmwZgj3RZeM4xkMeg2Q5yy6/r5q1gmm51npsM9EmGlOIpZwvjFS3zINOR5l+X+DOvbs45yzwp9nnStF6MltAheIuiNHhNRYzMvt9ty/kputg9Ju20tKox0mPuIEQOiRGJBptsHHOaHbb1kGnmsgZv6OvUuglBapwxklPTUucKrHvofRhHQOdqgOFIFPaEY77WQQd5e1X3+HK5TluNp/Md9BIFwa64S6PPPYhTk5us9qSoPOwxx7be2zvArZ3+gEw9w1OIo10vHl7aSbvEIhubLumvuHWYx/lxa98kagD81yqFqx0rkwj/kQtPyXq78eUd9m6bqOJW5vcedTBJ9M0RrCcDcacXfLLly+b5qOgEquOTPncjjHzME7eCRsbbfOzz06Caamg1cTkzIIpmUvd4DylPIFrZmcqJo4XZs3GN49b6pq8C/4ET+NnOG/C4jwQhxR8rBKQ0jk2wWzaUhLORhi6wHr1CrPDyww4QumIlX3kPdevXuLVtwbCsKSZHTAMwyRb9WGPPbbzuffYrsfDxvZOPwBEhEZaiI5G7nB89UkOjw+gG0EdVWgOrnDjxi0evPMCvUJ0HpfMvdw8IcZIHMJESyCxEwqNTrP2MFSm5raiWefPuUn0vnrUCSzTkbULrWq0NxWdr5zR/JFEXKhYIC7VLME4wGNtlWHsUARI8jvWvt5xkSvmQbA2eW07M3OYYUJzq79XNM8qiLgJ5uz/tIqKOnk9u0HrbMn8UzNB7L3NcsgenBAksh56nnv2U1x75AlgATg0tTqMcSB2CnGNb24Rl2/Q94E+nKKqrNcX5wLaY7uccY/tPN0LwPZOPwBCsEzGRhwSGh7cfY12cUg/LCeLCHB89VG61V3inTuF7eCyAKQqf5maNdnMBN5shhpQsz9zNMt+PaMcb8v3RkEZ/aV5mIa2jaKX6o1AlY04FcQ6QSYLWTYlxTeTGuv5XKIUjrc6QRpP6xykZtWqU/DXGtbIHgnGvqhM3DxiDEDdv7b+TNWO8BxfroZoGm21FuNcPNDwxotvcu3WJWZ+jjS1H9t8oyF2XH7kJi+9/BLL4a6V++3GLMuLGnts77G9C9je6QdAbgLhnENcRELk7bdvszicmWYhdbAqcv3GU3z11Z+nP72HSwuQU+Hz5yYt2ASGZHpTdevJpvUkSWdi7r734vZ9P/nepnk6/uQmDhYEKpqTYnOqfJw92fy0So3xnEB/FiyHJM0vbBGi8XfTNCX5JaSiYBbYOisU4sZ65+lsReU5oymlgFauP2Paj44mNkwEZdwrC4xZpuYo2E0zK4IfBuVLz36RO29/icXhYzhyaYSR/hhCIHIXFw8RHWilZRg68g3kImMAe2zvsb0L2N7pB0AIgXV3StR+zLCLSxq5zqofWA9GeRscBPWIO+Cxx7+dLzz786zXa+svmvbZnv2OATlDJLMEG1gPffWqCWWuy5Kf1kUow1DoaTAyA/LPJrf33TYksySca8r3zOJNmlt6os80FaZKdD6lB2JFoYvp5pGAFCHST9gReW7iHSQGhApEF4nOhNAjiIxBsAlDJDqrqjjOPpnCgsdhdU5MM3KYVpp9oc4DEjZM4FQz3o+p8aXSpEQ0BBhCosZFvFjS0YN7D9DhbZ762G/EN3N6GYujZVM7hMBTT3ySN15/lUCgXRwwaMyGP8189l4QfN/GHtt7bO8Ctnf6AdC0gpPWaom3DQPKTBpO77/FrVuPE9YnhJDqlkgkiGO2mPP0h76B15//NVwXLFjmQb3D09NgfGoRBekJKB1GqWuLf82A7pqG6CQl4ig13U3FlQSWbQwKyJS26dM4MjbxmI6x2UPWnMbXfDqnZ6gyQfPrEUd0vsxPxBvQJCLSkil/duxztrxK/4epcJwN9lVc7cSaiy5YLE8aExqm1MKaOlf7Q+v32chenaxbHHnrp6cPePH5X+bKI4+VtczXlo+77gPd6evcW4OGjplvWD44SUXUXNHcLmrssb3Hdv3+RWF7px8AIQS6fslqvcQTmHksEOaVt15/ncOrN8yUjMEq+6kS1OH0EJXA62++SN+NT9icQedcY9xZhTaaFiTVghVgu01QGUtiYg5WGsqm+Zy1ElVliELEpwzAUHyHE8pX8SeeBWb24+ZzTLQXNxUA+zub+/HrYgQ4Aj7XQNcUiFRnCSw6ZUvUwa00O2uykYQjm811Eo6qTqotpsUjV2i0H7sh5JIH0Yl1ktJgfUIaz/11z69+5ue4dvkqR7MFTdLmckp/jJFh6Ij9wFMf/WZef+V1m0vS3DYpdxc19tieHmuP7YvB9k73AzDTLjD0nuVpx+HhIV7XxBiITljev4NGQTvh4ODA/GsCzaUjLslTvPHac5y+fYdnvuG3UGM9CMbj1RYVtVwRNUERQATrGJT+7zXVXNE6mGaBJHFSRCObeduKVjkCxFAoXiVbEPPnee/P0MtKgkqlTeSesHlsaiJjlmAzeb0e9efOGwb2QIgO6HGSrkl6ojpcBO8yfa8HcdZNaaNmSm0Oi2StMc/dU98LrFuUK64Nn/yeiIXX1qeB5Vtf4UgamsMFIXp80grjoISwZtWbb/3wMHL7zYiL94gixCFCTK6PGImht/lf0Nhje4/tXcD2TlsAqgrR450iLtL1J+isQVN9cMGDb3DOsVyemD9OO2KA2eKYR259kH52j5N33jaaXG5mLabt5GJWQaxeyUCgk1DqluSfmfMQrTDTEHtEtkX5pQCzBkY9at9pbTbWXO1tow6sicg0CWXjc+92jDyapsFJg5N2ollN/KEaph2OUj15F9vSVzbGmJJepscYNZIpy6H2j079ysOEg96Ko5U6mAhxEF77yueYXb7CN3zTt2M7aX7tYRjwITAU4ROu3vwQq5M7xrRpGtOIZZxn41q2sCAf2thj28Ye2xeL7Z1+AIQQEBrCAP26Y+h6Yj8wm81wOiCxx2kkBAsGdUMk0CbwzWjn17h185N87eVf45VXX0DDGhLf2MU6485M3EzLg6lmMWAshlwSN/vsNkcORm2+ZmOzOmN6NWDlYUUm59wmNCWtXKFJZWpjagm3bdQ+T0gJMFXzjFy73HtvzSWio9eO6Ow6Sc0rvMRihm7OpRbYQnWLY72VfE0Z8PU1NtF+xjHCUcTM5MELS+146auf59qTNyA4un7N1WtP4f0BIfR03Yr7w5r16ZLYW0njl198gU7vM5/PC2vFmDcWTAzBfOsXNfbY3vjsHtsXgu2dfgDEONCFFa4FDZFV8KyHwGq1YtYegHqiDmOruRCJ/WCdj2JM/N8jbj35CV5/6Qu8/srrDNqXjMgBIUgDrmdWNcvOoyEJkyZeceJcS2qpZ09+0OgRnfpJx6JcNnJQ68yQuJU9sC04tTkapzTe5r1NQ8rHMx9tNnPtfMgI4OzPjDHSiCudo4KLqPjEegjFdEZClQjDpEZKDmaN1z3VigAkDLQCsbHCZ3l4BQmxrKKLiqwjz33+01y/fpV2tijJSF1/QjtfMF+03L9/n361BBm4+fhVnnjmg1x95BlCCCyXS0IIKZlIGbqe0A9msl9cCGCP7fcYe2w/HGzvdAzA+5YwQDcEQPAx4AbFNQ29QnvYEpY9SqoBbgYaUYVZaynRtII0hzz1oU/y0pd+haPF7+DStevmDE3akeiMQRTtBxrvic42dZ3qj8tgSTu0jQXmAMhsBQUGIuYjnLIY7DSbGs95QpC1iLo41eT9HJs7T36S9lOCbZpS4TOQ68q2yZ9btBhvdwKX2CIuKoInEEApdWrETTWLzHE+M5XMTXejC8Bqxyf3g8bie80ZrUFsDRqS1hgczz//j7l16wosbhJkDU5KhmuUAR9bPvCBD+Dml3nhq1/kzr2e9duv0WgSiqTNuuy/7r0Vy+r7M3N+mGOP7Y3399i+EGzvdEvIrzz/RdXomM1mrFYr2tZM4KZpkLYxf59zrFYrxCkxBpyY2di2LRp7S+dWYQhLTtcrXvzsp/jwb/idHF65wdwiYqgqq9WKZjEHYFSUcsu2yo8YFVFFE984543kyoxlaENpE5df0mnFwvfShmphCSHQuinj4UzAK7WZK23pNs57RgjPofjV36uPDWeFZPuwwmE5Qec8jBVeeBEo8wNHAR0CL3z5WW7cOGBxdInGH9p14FLte9Mqgwt0qxmtBKKuuPPgJPWLNaxIGEoAcxgGHN76raZr/y3f+m3vrY6+D2OP7T22dwHbO+0C0uiI2tP1Jzg3mnN931t3nGR6LRYLGvX4FPhxosR+RZvM5xAH2vaAw8UNnv74N/HcVz7F+vQdKwebfHvz+RynA56aqytkvnKmdUmibImYCb05Ykzfk2GrX/Q8lsNItZua2/kaM92tNqfr9y1o1Z8RECCls2cmwtRk3TY2+d32YijH3ibck+NFLYXLNkfWwHLN81ZcCVi6aCVwdVC+8tyzXL06Y7G4AfGAMJAE1ZX1CKGn9Zdx4QTfWMLNjStXWd5/QFivkGAuFIegKdAnGPtFNeDk4hLB9tjeY3sXsL3bDwBVq9iXgkG55Z2IoP2ABKsuqKpIm57I/WBNGZwrTaSzT9MBs8Ulbj3zG/jq5z7FO2/fZtDKP5kyMp0D5+OkxK6q9f9cd+Z3wyUub0qmKfPNTThkQGgZe7FOMxnPDrfxMwKvTjfP53kvDWcySkBoM0/0Pb6ZLLcKAAAVhUlEQVS2zZSP1ns0X9PoFqgzMRuCuNH3mhpduCA0JYlmZKOU8zTCgPLKS1/m0csHHB7fBPGmbXlHr3DarVmHgdPTU4Yh8uDum0Q0BcGMZnf1kRuE2BHiivVyVfy34hx9Kmmsg6TA6cWMPbb32N4FbO/0A2BgTHsOweho4/+Bk5MTtI9oPwaunFeclwmgmqaxDXQDBwdHHB5c4uZHvpnPf/YXeeGlL7DsO4bsa03BJMFMZudcoW756PAybea92UwDkpYRfWnwkeeRh4H8bOndbWMr7S4ltPx6Ry1c72ae11rQ5u98U9BY13W3oGDWwCZdmIAuGoc9eiVIk24ufvTTNi0qnvW659nPforjo5bZwVUz+8USpEIcbzLeW9ZoF5WoPU0rNE3Der1GQqQVOD66hnPQrU9Zr+8ShsF+gu2Nn3kGtpvvD2Pssb3H9i5ge6cfAA0CjaeLIyitx+dQfH1dt+L09AGqQtv6yebHaP66rutMUJw9hQ/alksHh3ziG7+Vk7u3eeGrn2FY9baRTkwYdChMCciBpYbWtcVkzfSvQhGTsTtTNgNHkzMXcsqAaji7/NszLuvf9s9osv56Ru2XrCl8m2Z5PUYNMp8/aVqp8qR1h0rp/JXw55LDo5uhNovHlnfOOWSA02Hg1371/+HGjQOcPwAWpkEl32kIymplteTX6zWXDhY0mN90vRp4cP82Q3/KanmP9eoEiMzaSxxfPqI/7ei6JX2/wkkgNGluFxj/2mN7j+1dwPZOPwBCCMSut16iuQTqAGDNHvKGxhi5c+cOihVz6taBMFD4vwFPHwUXHD56ojQEPPODhief/Binwwm/8Av/G3fu3KHv+2K+qVqqeP4/OiUQSgGtsUPSKAze+yI8eUw1krGi33TUpuzZ8fUG66efOyt02+ZTn9NH+xkFKWlzye8rwfq3imhyI0wTYer1aGRl/s8cAEs3KfWutL4LIXDn5C5f+fzP8dGPfoz55WeYtQdE7ZDU+GMYOnLP1tPlfW48+hRv3b9bTOygDxDfoDKWKu67JeiA9y3XH3uMqB2r1brMtes61pPmJA937LE9jj22Lw7bO80C+sIXP58D2gm0ahxbAa8WCfeNFlMYYDabjdzpPFKadnSOtpmnp24oP0Nc8s7d+7zy/Gf44Ie/nRs3rqX0e6VJLIlOQ3liZ0Dk7Mic7g5TNoSl2KeNdAMaFiBTitYI2P+fz2J1lR90OrYGvMqov+MYg3r2d5MIgb3GLUI1MkckGE1QJV+78cbL1ahDU0ZMK83o+3WOLgZ+6VOf5trVUx679UGcO6RpPepahmFgUEvkWa1Wxo6JyuNPf4DnvvJl2thhN8sIssZJi9KhIbk61OiNvjE/uzJw+/Zt+nXHbDZjCHYNv/t3/94LYQHtsf11jD2233ds73QeQK/gvDV1CAIxBFyTmlPrgPiBYTAKWM5eXA89TQgcHBywWq2Yz+eEIIQh4Ga+BM9yUof3Ht8c8si1lkP/Lbzy4q/x+ksLPvkN38z88mUGl+q1q3GhBTPfoxOG0ON9O/E/+gSq6JKgOgcoxLaYthm8qsYYMJApmZoHm2yEdxGguutR+ty2lnAmLNPjj8cdNZsh8cJDyiRxMj13jBtNLRxYvXKlD9EaV4ixWLyz1nhBkvsigX5AWfU9X/7cZ/jARxc07TMMcsjc9Sxjw8w7upSA08eAeEc4PeWZj32c57/8VXxY0XmPdD1Kh3dC1LVp0mouFNEWlRVdF4EO71uuXr0KUXn1tRc4nB0wXCALaI/tPbZ3Ads77QLqwmBMBie2Ec6VmtcDyqCjlhKCorEnrjpCP9B1llZfZ++5aDStrhvG2iOAkxnCjOPjyzz1wd/ArUdv8Ku//A95cPc2w/rUaHgRCB0STeOyBPPRh+m9+UCHNDeJa5xOzbDC8tCRuxzEpdZ3Y2BvM6h2lkY3MhXsx5GTc2qNMR9rFLhsolszDQkDnY8QrS55WHe0rVWVzL7MTGvL/t/M/HAx4FPdGGuAEWm9MSKEGermBLEa9aixKyIwxMhbb73B//t//D2OLi84WjzBQdviWVkCVDM2HFn3HX3X0Z3e55mPfYQvPPc8hKWtWegYJBAj9L0SgwUPG2fUOFA0zmibBlTp+zUxDqjAo489w7Lv6JYX5wLaY3uP7V3A9k5bAE3TlE3P0fecMdinpJk2aSkaO4YQmbVmYrmup2nmNE1j6fVVwo1HGFY9ft7gJGs7grQLDpuWw8MFB3PPSy9/mtX6Ep/8+DdyeOkYUU9U8D5ab04M3N57XIy00phZqIFsKEpwiFuhtMSoI3c3XaP5G411AMBg1SBh9HnWpmV+XUSwdoCp0xFZ8zJhdYkfPZbZNeCU44oVtmrWdj5RpW1bhhDQEAlN+n5UxHnLsnc9mkxdizMpzink7EYBjSASaRSipvqJAoNGOiLPfvbTuHifj3/zN3FweJw6G7W0zZxBXdnnYRgYQqCJK24+8y18+jOf42DuWEbjfMug+LYjMKN1isiQri2b8aAaWXcBcYqG1GzbO5CGRx/9AKend/4ZovXXN/bY3mN7F7C90zGAf/Ls59TqaGfz0iPR6GmZ/tYkcPiUep3pVE1r/88XhzTzGbEfCq86a0iqgdlsQbOYs16vieLwPajvcM6zPjnh9p0XeOVrb/1/7Z3ZjxzXdYe/u1X1MsPhzhFJxVK0xDCUPObFziYDCfJvB0ESW5ZkIY6FGLAsmqIkKuI2w6nuutvJw73V3aSEAAGisIG+3wuHw+lhdfepPsv9nXN4462fcOPqKbPZzmYjqYZBaceWrEBltGSgGtML2eq2birmu2N1oaaRMW4iqt16r6rp5vc14Uy/f7VaMe9n5fH155La2UFrbb0h4zZaku3KuqnckOunkauaZ1GuDCarB1xu51BqWl+odTnA3Ly+Wm0UFo+ePObe7z/htZsndItT+t6g7LLc2FqhdUfOkRhLU5L3ntOrC+49OcKorwn+ORIdmUBOEUXpls0yYpPBmXKd5YM14YwlxkjCY9SCFAZEFCFG+u6IaUPVe++990rOAJptN9veB9ve6wwAJu1tputsjYZyfTM80/zwskpNUKrU8bQpqZaxHavhOV2a0/dz+l5tUjCtNZJdeWOCLtuVEHRv8b5EMd1izhX9LsvFVR48+C1Pv33A7Tvvcv36TbKK5YbI9fAMSs1SygajEgkltHY7Ri1QNxhJnbsipBJNVA2wiGC1QYkQZdtcU24YakPK9GeJlCYZXybR966MAACoabwGlDagctkRW75TpGJKIUqRRBC2m57MzvUAZEKpvaqM0Y6YPHZHZbEpOdgOVZuaYvJkb3j4xX2S+YY33nwX5Xqs6dA7a/JEq50PsFLnfevtt/n1b36H5hnKGaI3DONAiBmnA7PekdJIGIBecG5WoiEJGNOTcyrdsEmTTMQ4Sw7FTlL2hDiw8/nzSmi23Wz7Vdv2XmcAH336G8l5dxGEJlcZV1//Hv1I13Xl+6xJCZztQWWCF6wrdVC0YrackaKQpczyGIZho4gwxmDddvxsSuWxKUXIEGXN428+59uH9zi5/Dand9/hZDkj8f3dj9s02OzUKssibJGS3m4fl0tttdYyJ+OftjbtNv7sMg2gmlJybc0Lo3wllRTeKEVKYbOlaYpcjFKbhhE1RW8pVUPbvhYvp+mblFgEUsba6f3p8DlgJLMahP/49w9ZXn7GzRtv0vfXUHaJ92tM5zYpvdaaEOtmqeRJw8iV09d5+OiPGNH4kEgIZ8+f1ZtKyrWFRGc0RpX0Xmtd3kOKxFGpcuNZNWns+/pBk/DeM21r+tlPf/5KMoBm282298G29zoDmN7wslFIk/KKnHX9GrIqaVEIAes0YVRoA6MfUEpjnUMrS5KI047zswuOLy0hlqc96xeIZATKyr1YN+4sj2s0lUEU2mg6pbl+6y6Loxs8/OoL/vOTf+bOj97k2s3XSxONcxsjLqqArfEZbbazWVT5ZjFKSFK1F5s6X6l5aq2QDDmnWuuE6TBNiX7h9H7695fnuKuaiguUhSHTCjosRgkiGcW0gETIm9fbEaviYxo9UK5t+7WWMp9Fm55Un3PMgefPn/PFvc9YnX3L3Td+xHz2Jsr1KOOAuo9WimJFa6mpbYcPa9arc45PbvPo8ZeQNCmX0QMX5+eolJihWXcQfEIrIeYA2iExYxUgmkSRwikBazWSHAoYw1mZn+51qbOq/0lG+MPTbLvZ9j7Y9l47AK01BkMOmUBZjOEy2M6yHs6YzWZIrlGKaPqZK9rnWA5ElFIkyXWWRokKVs8vmC2OMNqQUygHWyRCTjgzI8qKi4uL6nknBQRItsCCk8uXmS8usx5WDGdf8cnH/8Rbb/4Fs6NLLBaLknbCzgq8hKQEqtZSASjr97IISlPTVbM5eJqiKk3RHk868Y1oSxXVgZ4OhV56r6foR9XDrKSFkqJLfUye7uEpYUbp7QGcUgpTpzNOV1wilG3RVymDoSebRPClcenBZ5+xDg+4cfM1utd/gtUnAIjKxJRKHdq4GoWV5xZCQNIZt27d5ot1z2r9NZIdiowPkeASubewyqwMEBSSIyFnkoZ515XDSxSohMkdORm0TngfMboMCevcguBjKaHE+lz1qxsJ3Wy72fY+2PZeOwCVE15S3eqjyFnIWgjDBZ3tSaFEHs45ECkpcAZnOgKC9ZmVRKwtL2CKPcYK42qF1uDms+Klc6lbRj9gjOO1u3e5/+D3WDMvCgqlCDmhzYwMGDfj6LjnaLHg8tU7DBfP+PzTX9O7a9x64x2OlnNcnd44pclGIohmCniKlwZEUCqDlOXOk/EKmqwyutZYjUCq9WDzUrelrtFTVAnyDCURci7NPYBkRdIKTSbmVAyqXkNKAWu7OoZAYYwmpYg2U2pfoj9nNV5U0XRLmUjpY+Tx4zVf3PsFN65d5vjKLa669+hmc1KGQClxaNEoBSYLXgmkgDPHDOGMmUlcu/5j7t+/j6iBGAxKSelmzJF4Fkkm45Si04YYPNlolNF0WFYalmEk9keIHzEmY3ImJgvOIEnwQdBqRKmOEMb63DMp/u9nzvxf0Wy72fY+2PZenwH820e/FGNMnXVSbghLh6SMrcO0jHGkvMZqS8wRo7tt67axYNJGwZBT6abUtU4YEZbLJToXFcFUMzQu4y96svUcHV2CFJGNfC1hVZnbjYpVGickv+LJ0y85e/aEx48ueOfHf87JySXmi2Ngq5Penb8CJfp4eenEpL4oUc32+0l99+dfTvemBpzdppisyhwYLZSDRgGMfmFc1KSHtk6R4qS/VqUDURRZdZg4MiQYRs+93/2Wp48+4/brb3Ht6indbI4ypjS2pFxq1WybmGKMYDR936NGCOEJp3/6Ll/9cWDlvyrXWScfrkNRw4jKhDhic3nuY/DYWY+EiPh6YKrqQhMVWKrLKCmdlVEJLq3RuiOJoCQQfSLnujxDCcFn3v/bV3MG0Gy72fY+2PZeO4BffPyhgMa6YuBgcTuLKJRAih6lDGpncFVG6LoZWWV8CCidsWZJSuPGUJ1zgEbwaDcrKS6UwxWK8iCZjtu3XuPs0UPO4jnOzoqhVcMruudpjnjpOUn+ghQiw/Nv+PrhfcZoePvP/pJLi57F4hIx+vp/lzqv0KEY0Zv9p7HeJN+V0r04gGv79TSyd9oFi0q1eDrJBxWQkRpNpZRQxoIyaFUvvCIiaNVTBl9pgkTGccSPK54+WXPvsw+4dnnOzRt3WCxPMN2SMURsv9i+L/W6pg8jEWGxWPD44pyUEtfv3OHxowvi8PgF2WNIkfV6zVpF+mzwRLQXPGAtBK+JyqNFIzluPjC2JYTMojYK9VWDHvDYVEohKltyrzBxhfcl+vvrv3r/lTiAZtvNtvfBtvfaAfzLr34pU0QwzT4nhq0sS2uiD0ya4s1WoNroEdmOy50kYH3f470vqXdVEmBNiZ60rY0rta5aW85DOGE2P0Mk46Ni5qbKmd6oD6brUVIkX85YhvWK7Fes1mc8/PIBwzCwPLrGletvcfn6CUsTcd0SeMn4a0Q4GTpklKYM+krbWSbiUrHvevA0sy8u0Z5+53TAVXTnu92TFLmYCmU2PWymU56fX7BeXfDNgz8wXHzD4mTJzSunzE9uIynh+hkGR9bb36cA6k7ZlMoHkXOO1WpVboJ6WBjydsxwSok1iTB6UizRzkQOEWUVIZYILoyRfj5ntRqgC+hQ5IEiQo4BrTULW6Lkrq8t+rGM09VGGMcRk4SgStesiPD+3/z9K3EAzbabbe+Dbe/3GUAq80YmLx9j3CytnhQSkjN93zMGT0qCUsUYYvRgTU2ZDdaWA5pyQl/SN11VAOIDPpaZLMvl8oX5K0JiNntOQjhf9Vw9mZPG8+1CDmdRCqwGciaILrplEfpuQe4Mbn7E8cldkgz486ecnf+Bzz99yvO15vat1zm6/hrHXYeb9fWQbUpRZaO60AI5rkuKaw2KDp106WKUTOd6Qr0BLEXKlqTox/Xm77VkQEZSRmJCOUvwkdGfETx8+K8fsDzyqHzB7Tun3Dq9Tt/9CXYxQ6Jg544ULcZaUtRkIk7rTRNT0W2XiZHjOBJCwOdAKpVfoCzmTnWS4oVEVPDoHEl1Nkua9qsaQ4xrZtawGooaJsaA0RmfNTpFou5LpKsNMWeG9YhzjrMYOcqGZBJ6DASj8KPC6YjRmvg9s+7/P2m23Wx7H2x7rzOADz75WEqLu0FEYZ0gXraHYxQ9cEoJ13cMw0BnHWKL/tYpwJptVFA7/QzbqGq6IXalbr3p6LoOqvZYazaPTymhzYKrVy5x/uy/SNHQ9z0ixbtL3cNqrd10Dk7RidaWvFqRuSBI6SxcX4yMw9es1ms++tUn/PRnf4fpllw/vYPKQqcVym03P8FWsjY1m+zqqXfrryKy+Zlx5XFGMQbhYjXw9NuvGIeBwX9LSoHjheFoeYPZ8SWcm9G5o/Iaa40SIWSFtd1GYzxhTYlGsod+VqZYTrNJJmXF1JQipmyyCjUSS1JWICoMIY6sQqy7cYuWPWUwNjGuIs6V6HYdRzpryatINqpEXmsPZkZmxUDiOBtMfc+csaUzkoEULNbVufapvE//+PN/eCVeoNl2s+19sO29dgCNRqPR+OHY62mgjUaj0fjhaA6g0Wg0DpTmABqNRuNAaQ6g0Wg0DpTmABqNRuNAaQ6g0Wg0DpTmABqNRuNAaQ6g0Wg0DpTmABqNRuNAaQ6g0Wg0DpTmABqNRuNAaQ6g0Wg0DpTmABqNRuNAaQ6g0Wg0DpTmABqNRuNAaQ6g0Wg0DpTmABqNRuNAaQ6g0Wg0DpTmABqNRuNAaQ6g0Wg0DpTmABqNRuNAaQ6g0Wg0DpTmABqNRuNA+W8Y/Z5p5/F1GgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x864 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 随机填充\n",
    "def random_expand(img,\n",
    "                  gtboxes,\n",
    "                  max_ratio=4.,\n",
    "                  fill=None,\n",
    "                  keep_ratio=True,\n",
    "                  thresh=0.5):\n",
    "    if random.random() > thresh:\n",
    "        return img, gtboxes\n",
    "\n",
    "    if max_ratio < 1.0:\n",
    "        return img, gtboxes\n",
    "\n",
    "    h, w, c = img.shape\n",
    "    ratio_x = random.uniform(1, max_ratio)\n",
    "    if keep_ratio:\n",
    "        ratio_y = ratio_x\n",
    "    else:\n",
    "        ratio_y = random.uniform(1, max_ratio)\n",
    "    oh = int(h * ratio_y)\n",
    "    ow = int(w * ratio_x)\n",
    "    off_x = random.randint(0, ow - w)\n",
    "    off_y = random.randint(0, oh - h)\n",
    "\n",
    "    out_img = np.zeros((oh, ow, c))\n",
    "    if fill and len(fill) == c:\n",
    "        for i in range(c):\n",
    "            out_img[:, :, i] = fill[i] * 255.0\n",
    "\n",
    "    out_img[off_y:off_y + h, off_x:off_x + w, :] = img\n",
    "    gtboxes[:, 0] = ((gtboxes[:, 0] * w) + off_x) / float(ow)\n",
    "    gtboxes[:, 1] = ((gtboxes[:, 1] * h) + off_y) / float(oh)\n",
    "    gtboxes[:, 2] = gtboxes[:, 2] / ratio_x\n",
    "    gtboxes[:, 3] = gtboxes[:, 3] / ratio_y\n",
    "\n",
    "    return out_img.astype('uint8'), gtboxes\n",
    "\n",
    "\n",
    "# 对原图做 随机改变亮暗、对比度和颜色等 数据增强\n",
    "srcimg_gtbox = records[0]['gt_bbox']\n",
    "img_enhance, new_gtbox = random_expand(srcimg, srcimg_gtbox)\n",
    "visualize(srcimg, img_enhance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **随机裁剪**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "随机裁剪之前需要先定义两个函数，`multi_box_iou_xywh`和`box_crop`这两个函数将被保存在box_utils.py文件中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def multi_box_iou_xywh(box1, box2):\n",
    "    \"\"\"\n",
    "    In this case, box1 or box2 can contain multi boxes.\n",
    "    Only two cases can be processed in this method:\n",
    "       1, box1 and box2 have the same shape, box1.shape == box2.shape\n",
    "       2, either box1 or box2 contains only one box, len(box1) == 1 or len(box2) == 1\n",
    "    If the shape of box1 and box2 does not match, and both of them contain multi boxes, it will be wrong.\n",
    "    \"\"\"\n",
    "    assert box1.shape[-1] == 4, \"Box1 shape[-1] should be 4.\"\n",
    "    assert box2.shape[-1] == 4, \"Box2 shape[-1] should be 4.\"\n",
    "\n",
    "\n",
    "    b1_x1, b1_x2 = box1[:, 0] - box1[:, 2] / 2, box1[:, 0] + box1[:, 2] / 2\n",
    "    b1_y1, b1_y2 = box1[:, 1] - box1[:, 3] / 2, box1[:, 1] + box1[:, 3] / 2\n",
    "    b2_x1, b2_x2 = box2[:, 0] - box2[:, 2] / 2, box2[:, 0] + box2[:, 2] / 2\n",
    "    b2_y1, b2_y2 = box2[:, 1] - box2[:, 3] / 2, box2[:, 1] + box2[:, 3] / 2\n",
    "\n",
    "    inter_x1 = np.maximum(b1_x1, b2_x1)\n",
    "    inter_x2 = np.minimum(b1_x2, b2_x2)\n",
    "    inter_y1 = np.maximum(b1_y1, b2_y1)\n",
    "    inter_y2 = np.minimum(b1_y2, b2_y2)\n",
    "    inter_w = inter_x2 - inter_x1\n",
    "    inter_h = inter_y2 - inter_y1\n",
    "    inter_w = np.clip(inter_w, a_min=0., a_max=None)\n",
    "    inter_h = np.clip(inter_h, a_min=0., a_max=None)\n",
    "\n",
    "    inter_area = inter_w * inter_h\n",
    "    b1_area = (b1_x2 - b1_x1) * (b1_y2 - b1_y1)\n",
    "    b2_area = (b2_x2 - b2_x1) * (b2_y2 - b2_y1)\n",
    "\n",
    "    return inter_area / (b1_area + b2_area - inter_area)\n",
    "\n",
    "def box_crop(boxes, labels, crop, img_shape):\n",
    "    x, y, w, h = map(float, crop)\n",
    "    im_w, im_h = map(float, img_shape)\n",
    "\n",
    "    boxes = boxes.copy()\n",
    "    boxes[:, 0], boxes[:, 2] = (boxes[:, 0] - boxes[:, 2] / 2) * im_w, (\n",
    "        boxes[:, 0] + boxes[:, 2] / 2) * im_w\n",
    "    boxes[:, 1], boxes[:, 3] = (boxes[:, 1] - boxes[:, 3] / 2) * im_h, (\n",
    "        boxes[:, 1] + boxes[:, 3] / 2) * im_h\n",
    "\n",
    "    crop_box = np.array([x, y, x + w, y + h])\n",
    "    centers = (boxes[:, :2] + boxes[:, 2:]) / 2.0\n",
    "    mask = np.logical_and(crop_box[:2] <= centers, centers <= crop_box[2:]).all(\n",
    "        axis=1)\n",
    "\n",
    "    boxes[:, :2] = np.maximum(boxes[:, :2], crop_box[:2])\n",
    "    boxes[:, 2:] = np.minimum(boxes[:, 2:], crop_box[2:])\n",
    "    boxes[:, :2] -= crop_box[:2]\n",
    "    boxes[:, 2:] -= crop_box[:2]\n",
    "\n",
    "    mask = np.logical_and(mask, (boxes[:, :2] < boxes[:, 2:]).all(axis=1))\n",
    "    boxes = boxes * np.expand_dims(mask.astype('float32'), axis=1)\n",
    "    labels = labels * mask.astype('float32')\n",
    "    boxes[:, 0], boxes[:, 2] = (boxes[:, 0] + boxes[:, 2]) / 2 / w, (\n",
    "        boxes[:, 2] - boxes[:, 0]) / w\n",
    "    boxes[:, 1], boxes[:, 3] = (boxes[:, 1] + boxes[:, 3]) / 2 / h, (\n",
    "        boxes[:, 3] - boxes[:, 1]) / h\n",
    "\n",
    "    return boxes, labels, mask.sum()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x864 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 随机裁剪\n",
    "def random_crop(img,\n",
    "                boxes,\n",
    "                labels,\n",
    "                scales=[0.3, 1.0],\n",
    "                max_ratio=2.0,\n",
    "                constraints=None,\n",
    "                max_trial=50):\n",
    "    if len(boxes) == 0:\n",
    "        return img, boxes\n",
    "\n",
    "    if not constraints:\n",
    "        constraints = [(0.1, 1.0), (0.3, 1.0), (0.5, 1.0), (0.7, 1.0),\n",
    "                       (0.9, 1.0), (0.0, 1.0)]\n",
    "\n",
    "    img = Image.fromarray(img)\n",
    "    w, h = img.size\n",
    "    crops = [(0, 0, w, h)]\n",
    "    for min_iou, max_iou in constraints:\n",
    "        for _ in range(max_trial):\n",
    "            scale = random.uniform(scales[0], scales[1])\n",
    "            aspect_ratio = random.uniform(max(1 / max_ratio, scale * scale), \\\n",
    "                                          min(max_ratio, 1 / scale / scale))\n",
    "            crop_h = int(h * scale / np.sqrt(aspect_ratio))\n",
    "            crop_w = int(w * scale * np.sqrt(aspect_ratio))\n",
    "            crop_x = random.randrange(w - crop_w)\n",
    "            crop_y = random.randrange(h - crop_h)\n",
    "            crop_box = np.array([[(crop_x + crop_w / 2.0) / w,\n",
    "                                  (crop_y + crop_h / 2.0) / h,\n",
    "                                  crop_w / float(w), crop_h / float(h)]])\n",
    "\n",
    "            iou = multi_box_iou_xywh(crop_box, boxes)\n",
    "            if min_iou <= iou.min() and max_iou >= iou.max():\n",
    "                crops.append((crop_x, crop_y, crop_w, crop_h))\n",
    "                break\n",
    "\n",
    "    while crops:\n",
    "        crop = crops.pop(np.random.randint(0, len(crops)))\n",
    "        crop_boxes, crop_labels, box_num = box_crop(boxes, labels, crop, (w, h))\n",
    "        if box_num < 1:\n",
    "            continue\n",
    "        img = img.crop((crop[0], crop[1], crop[0] + crop[2],\n",
    "                        crop[1] + crop[3])).resize(img.size, Image.LANCZOS)\n",
    "        img = np.asarray(img)\n",
    "        return img, crop_boxes, crop_labels\n",
    "    img = np.asarray(img)\n",
    "    return img, boxes, labels\n",
    "\n",
    "\n",
    "# 对原图做 随机改变亮暗、对比度和颜色等 数据增强\n",
    "srcimg_gtbox = records[0]['gt_bbox']\n",
    "srcimg_label = records[0]['gt_class']\n",
    "\n",
    "img_enhance, new_labels, mask = random_crop(srcimg, srcimg_gtbox, srcimg_label)\n",
    "visualize(srcimg, img_enhance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **随机缩放**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x864 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 随机缩放\n",
    "def random_interp(img, size, interp=None):\n",
    "    interp_method = [\n",
    "        cv2.INTER_NEAREST,\n",
    "        cv2.INTER_LINEAR,\n",
    "        cv2.INTER_AREA,\n",
    "        cv2.INTER_CUBIC,\n",
    "        cv2.INTER_LANCZOS4,\n",
    "    ]\n",
    "    if not interp or interp not in interp_method:\n",
    "        interp = interp_method[random.randint(0, len(interp_method) - 1)]\n",
    "    h, w, _ = img.shape\n",
    "    im_scale_x = size / float(w)\n",
    "    im_scale_y = size / float(h)\n",
    "    img = cv2.resize(\n",
    "        img, None, None, fx=im_scale_x, fy=im_scale_y, interpolation=interp)\n",
    "    return img\n",
    "\n",
    "# 对原图做 随机改变亮暗、对比度和颜色等 数据增强\n",
    "img_enhance = random_interp(srcimg, 640)\n",
    "visualize(srcimg, img_enhance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **随机翻转**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x864 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 随机翻转\n",
    "def random_flip(img, gtboxes, thresh=0.5):\n",
    "    if random.random() > thresh:\n",
    "        img = img[:, ::-1, :]\n",
    "        gtboxes[:, 0] = 1.0 - gtboxes[:, 0]\n",
    "    return img, gtboxes\n",
    "\n",
    "\n",
    "# 对原图做 随机改变亮暗、对比度和颜色等 数据增强\n",
    "img_enhance, box_enhance = random_flip(srcimg, srcimg_gtbox)\n",
    "visualize(srcimg, img_enhance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **随机打乱真实框排列顺序**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 随机打乱真实框排列顺序\n",
    "def shuffle_gtbox(gtbox, gtlabel):\n",
    "    gt = np.concatenate(\n",
    "        [gtbox, gtlabel[:, np.newaxis]], axis=1)\n",
    "    idx = np.arange(gt.shape[0])\n",
    "    np.random.shuffle(idx)\n",
    "    gt = gt[idx, :]\n",
    "    return gt[:, :4], gt[:, 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **图像增广方法汇总**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAADHCAYAAAAQ7YTfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsvXmwLFl+1/f5/c7Jqru9+5bufv26e3qmJY1GM5qRGAnQWLYEEpssrA0MtkTYDhEGsxmJMAoWL4AJs5iAwDgAi7BshA04QjKBkISFhADJLAYjjEA2I41m6+np6fX1W+5amXnOz3/8zsnMqntfTw/qVt/pm9+IinursjLzZFbVb/n+NjEzZsyYMWPG5YO+2QuYMWPGjBlvDmYFMGPGjBmXFLMCmDFjxoxLilkBzJgxY8YlxawAZsyYMeOSYlYAM2bMmHFJMSuAGTNmvCaI8GMi/KY3ex0zXj/MCuANgghfIcI/EuGeCK+I8A9F+MWv07FNhHe+HseacbkgwsdFOBHhcPL4s2/2ul4PiPBVInzyzV7HZxPim72AtyJE2Ad+EPhtwPcAC+ArgdUD3h/N6H/+VjjjkuPrzfjRN3sRM958zB7AG4N3AZjxv5mRzDgx40fM+JcAInxr8Qj+tAi3gT9UXv/NInxQhAMR/pUIX/rpTiTCHxLhe0X4y2W/nxLhXSL8fhFeFOEZEX7V5P2/cXKOj4rwWzaO93tEeE6ET4nwm6behghLEf6kCJ8Q4QURvlOE7dfvts14M1G+l/+gfMZ3RPiYCF+78bZ3lO/ugQg/IsLDk/2/V4Tni9f7f4rw3sm27xbhz4nwN8u+/0SEz5tsf68If7t4yy+I8J+X11WE3yfCR0S4LcL3iHDjNV7Pj4nw3xRP/FCEHxDhIRH+igj3RfinIjw1ef+fKb+X+yL8MxG+crJtW4S/VO7LB8vv5JOT7Y+L8NdEeKnct2/7TO79m4VZAbwx+BCQyhfma0W4fs57PgB8FHgU+CMi/HpcEfxHwD7wDcDt13i+rwf+V+A68M+BH8Y/2yeAPwz8hcl7XwS+rpzjNwJ/uioaEf5t4D8DfgXwTuCrNs7zx3Hl9v6y/QngD7zGNc747MAHgJ8BHgb+BPA/iSCT7b8B/97cxD3b75hs+yHg88u2/wf4KxvH/mbgv8a/px8G/giACFeAHwX+FvA4/t36O2Wf3wl8E/BLy7Y7wJ/7DK7nm4H/EP+ufh7wfwF/EbgBfBD4g5P3/lP8u30D+KvA94qwVbb9QeAp4HOBXwn8B3UnERT4AeBflPP8cuB3ifA1n8E63xyY2fx4Ax5g7wH7brBPgvVg3w/2aNn2rWCf2Hj/D4N9+2s8toG9s/z/h8D+9mTb14MdgoXy/Ep5/7UHHOv76nnB/mewPzbZ9s56LjABOwL7vMn2Lwf72Jt9r+fHZ/S9/Hj5ftydPH5z2fatYB+evHenfP63yvMfA/svJ9t/O9jfesB5rpV9r5bn3w32XZPtvxrsp8v/3wL2zx9wnA+C/fLJ88fAOrB4znu/CuyTk+c/BvZfTJ7/KbAfmjz/erCffJV7dQfsF5T/Pwr2NZNtv6meC+wD5/yefz/YX3yzP+9P95hjAG8QzPgg8K0AIrwb+MvAfwd8S3nLMxu7PAl85F/zdC9M/j8BXjYjTZ4D7AF3i0v/B3FLXoEd4KfKex4HfmJyrOkaHynv/Wcy2oMChH/NNc948/BN9uAYwPP1HzOOy2e9d9524LhuEyHgFv2vx78rubznYeDeq+3Lq3/33wH8dZHheAAJ95yffcA+U2z+NjafD9cmwncA/zH+OzDcS64U1+Os/x6m/78DeFyEu5PXAvD3X8P63lTMFNDPA8z4aeC7gfdNX9542zMwcqJvBERYAn8N+JPAo2ZcA/4PGFz854C3TXZ5cvL/y/gP5r1mXCuPq2ZrwmHG5cVvAL4Rpw+vwsCty4N2mOAZnFp50LavnXznrpmxZfaahP9rRuH7fw/w7wHXy2/jHq/tt/EM8LGNNV4x41e/nmt8IzArgDcAIrxbhN8t4l8YEZ7ELf9//Cq7fRfwHSL8QhFEhHeK8I7XeWkLYAm8BPTFG/hVk+3fA/xGEd4jwg7wX9UNZmTgf8RjBjcBRHjis4LnnPHzgSt4lttt3FP8o5/Bvj8IPCbC7yqJBldE+EDZ9p14jOwdACI8IsI3vp4LL7gC9PhvI4rwB3APoOJ7gN8vwnURngD+08m2/xs4EOH3lmBxEOF98jqlfb+RmBXAG4MDPJj2T0Q4wgX//wv87gftYMb34i70Xy37fx+8tmyH1wozDoBvw7/Md3Cr7fsn238I+O+Bv4cH6arCqumrv7e+LsJ9PHD3Ba/nGmf8vOAHZL0O4K+/Dsf8X4CncVrmX/Hqxs4ayvfyV+LJDM8DPwt8ddn8Z/Dv6I+IcFCO+4HzjvNzxA/jQegP4ddxyjrN84eBTwIfw7/3/zvld1Ho1q/DA8gfw73l78I9oQsN8YDFjBlnIcJ7cMW1tLlOYcaMASL8NuCbzfilb/Zafi6YPYAZaxDh1xQ3/Drw3wI/MAv/GZcdIjwmwr9V6hK+APfmXw/P6U3FrABmbOK34LUCH8GzLX7bm7ucGTMuBBZ4Pc0B8HeBvwH8+Td1Ra8DZgpoxowZMy4pZg9gxowZMy4pZgUwY8aMGZcUF7oS+Kc/9DMWQgCyly3HBSl1qCpmiabZpmkaYoysUo9ZwlQApes6utTTdh05Z0SEhACZzjJbKiQTcu4xExoNNFtLdpsli8UCCUrIyunpMVthiYVEjELOnqRvus3O7pLT9gA5TXQGKSWQnr7vEFFSSkhKhBCwlEGF4+NjkBMs9xwc3CMdHXL34D7L3SvsX73OcvkQV/evITGQRAkhsNsEzIy+M2IjBFEyCbLTdxlDiGCZEIJvQyEbJpBzRrXoevO6lpwzljMnfSJY5vBex6p/mcO7L9NxyPXrjxLjgu3dHTTvYYJfhwiVNgwhIBLJKgSEnDPL5ZLupGWxNJbbu4jscnxwh/1HHuKUwMmdY/LqHrk7wUJEDfq+p+97v8a+JwTByFhWTIWUKZ+hIRL8PltENBEMVqsVMWq5Tr9MJZCz3/O2bQkLpW1bJCtBlJ5A27b8kn/zy19LodIbgZl7nfFG49N+ty+0AohRAcMMFosFOYOUKimROPzo+5whG3GhpN7ocsIsIU0kpA7BhbFGoe97Go2YKFiPqrKzWCIGTRPJAqigKXFyekIIgkiA3NKnBSpL9q5eoU8nnBzcpk8uccwSOSdy6lzG5gTWk3qj71tyOqVPLV13wgsvPk8MDXu7N3j4ifdxM26xaIzd3V1UlZRWQEQRLAnkjACxqQpLixB2xYZkMgYo1ifAEOkHQa0hggmiGSP7cRuIORKagIiws7tNznv0Nz+P0/6Q+7dfol21HNz5FKpHxO2r7O3cQjSytdgmNJG+S4SormSSV+qnlNBFwGLP4dEpGk7YfWhJWinN6Yssr13jNN3i4PZtyCcQIssQ6DpX7CG44BYFEcOQQdEtFlscHx+ztbVF15+gskXXrghNg+W+KIAFyYygQmgibdsSNaBJ2NYdWEDOkLuOna3Fz+8XesaMC4YLHQT+6Mc/YlIsTjMX/NCTsxJjJDaGSoOqIiL01mMobcqk5B5AjAvunRyxHRqy2WANp5QwNfcgJLKzs8P9o0Mef/s7uP/yC+zFJavWhcp2aGhD5qEbj5Isc3L/Nl3XEeKCrj0Z1mum5P7I19JnVumY3J9yev8eq9WK3b1H2dm9ws7OFZZbW6hGJCcybqlaWZ+IC3q34hMQUIlk6xFVsnUICzSU9xNBEpK9LY9JRoNhCcSA6B4TgGok9wmN7pWIunehpelL/TbU+54QTg6PODk54pXbL9J2r7C/3Gbv+i1C3CE2EOIWyYwYIwHFpEEkYFUJZYFFZtHsEnJE8hGL/euc5sDps5+gCw1GBwnatiXnnhACKbekPpMzhEUDIqRkw9pyzgRxBbw6OUFEiBowKa+rkAXUIJnQtj1BEn0GjYFu1fJv/KJfPHsAM96q+LTf7QuvAHLOEJSAoAgZQYt1mLOyWCyc3gjQpZbUu1A/PW3pJZGS0edTyJGUM6JGUCs0UkMIgZ3lFqenp0SBuFywXG4jfabtO2JUQtxn7+o2q9U92qOVC8ac6bqOZRRSSqSUiFHp+562bTm9/zz3To7o+pa3Pf4+dna3ictIo02hZlzQW8qAIpqwHAEXbGYGKogJBoiCWiRjpGSEUOmS4PuLr6MJkaEPXC7HKLxIyp7OXxUm2RBtAJBCszF0eotQ0v/dKodKrb3y8ksc3vskGk/YufIwzfbDbC8aQFGNWPHUKoXlCi1jJmRraeIullt2dhvy1g3aOwecnt4mEEnJ6LrVQAml1Dn9t1zQdi78xXDhnjORoqhSou97FouImRFEUVW65Mdx46EqVDDz+/UlX/IlswKY8VbFZzcFJAZRgwvuoP43BiwbqoGmGWPYBoSgmAhd1yFibqWLklNAQwLz/YK64MeU2EDft0AmIWzFiKUVoluItCx2rrK7vcX9Oy8UIehUh6uiTNcaRibbKcenJ/QHL3Nwr2dr/wZPPvkUO9tXmMYxMIEiEGMMZEt4un0sgl7ICVKfWCyXiBkU6sola4dIpOsSQd0r0pCLUogky4ALyRBi8Z78HqmEIgj9hlXFYGYYRbhK8QhwxWOFPgMQycQIjz52k1u3HmfV9rzw0ie489JHuH7zBmFxla3QEJqImYIaBvStxwb6vidIxFKPSODwMLNYvcRy/wZpucXpnRchtcTFFl06QVEIiojR907RpZRQEVozNBuGAkKMwmKxoG9XaFAWzWKglcQgU6jDIKQuk8RYbC3f2C/wjBkXHBfaA3j64x+1jPP0ORVhF8MQ0DQzlsulW3whkHNPSkabelYp0yW3kLtunMQoIiwWW8ToVEjXdWQT4iLR5V0+99Zj0MDduy9wZecWsoDDO8+RUsayoGLkfuVrypnupGfV3eP2vadRu8ojN59kb2+PRfOAQVnSAQxURr0u04zmUeCqKqrQt1Y8HqnxWxdoOYPaKLBVMRMP1Jq5h2R+Lsmh6J2AyPh5iwhYdPpl8lq1mEfLGYTkz7Xx+IqEwTNoU8vLL7/A8f0X2F1G4u5VthdXkQBN09BmX59KU9bqdocWbr+3lmVcQrPP0SvPY8LgVXUpOaWjHt/IAtmELieieKCbQgVVj0q1KJ/y3TYzD5SLDHGkzlyRf8l7v2j2AGa8VfHZ7QGoGuQIGVTFf9hWBCA20AsppcF6hd4tVzOiCqnvCKEZuPWmadjacsonpRWiS/b3rnL9xjVaW3F0+3ladrn28C1O+xXtvbtYEoI2tPkIsUjqoZcDjg8OObz/Ck3c5dYj72d/f58Y/ZYahXogDhY1MASNAcwySCKbISnS50yMoxBv2xYNgugWkKEK5EIP1c83xjGYWYPkzuu7cpRgYFYEt64JeNVETjbst4kqMJGA4ccBt6otZQxjESKP3XycfONRXnj+We69/BynO3fZu3KdnPdYLnbIeQWmJQ/LlXoq51voFn2fSOkVdq7t07Y9q6NXaLaW2MqD4Dl5FpBZxiwQC8VDTkgITquZERtXzAsCKxKNCSsxIPnoJvWYEcmzj2bMuMy40B7AJ57+sEkyRCBrsUTV0z6r1Y+OAs9U6Ap3vFqtILiwa3u3qLe3twuV0oI19KrcevRJAivu3nkeywuapmF7e5vT02PEEpgLFEk9RqZdHXBweJfDg5e5sv0I1x95O9vbS0RZE/iCewzVas+5UEclkIl0hZIp6YpkUhKCgAQdvZwcEHWOm+jXGaxYuzZVfMBkZkZWQfOY8ukegp0j5Os+YzbTpvW/5glM9k+pK5lJFAs/kAp1dPvF5zh4+Xl2dpdcvfooumjoi5DWRYPKsqR1CqFkNZk5j980DblfcnxyD9FEjJGTk5MhjlAD2v5/SUktXkNTkgVWEQKCZHMFG9yzylruVZ/IOfMLvuiLZw9gxlsVn91B4E88/WEbgnxhDP4JWyArYoxOSaiUDJFKUxhtu6LLmZwgZ2Vne48+naLmwmq5d4Pd/R3u3n+OfOIZLNIIsmqxELGiNHLOxKys2vusuld49tk7PPLIIzz80GMsl9uoOLdf8+2FBVWoOl9d/s+Vv/E15mQE3UakdYFbBXDKiAQ0Fr7edAjqCgEjufUtrAnlmhY6/Txlwvlvfs5CGO4VQCrLCzbm3Pt+1TMYFdj0WG3qaTQg6tlIKgtEvUZBRLh/dJcXXvwQV/eu0yweQmOHsk2IiqB0scHD0H79fd+jSTASy2XD/fv3S+5/55RY74on575QPqPXo6pY8fRgvf6hK+tJEbou0aBon/nC9713VgAz3qr47FYAn/zYz5r2/iM+VRfSmhNdUJbNgpwzzWLk2hNG1/e03Sm1fiD1xqJpSEGIeYvOjnn0bZ9Dn1oO795xwV+FXjZ6haakGDb09DnRnnY8+/wHUXZ48qn3sLs14feLQId1IZvT2Xs/WKvJ6EsmThVSQhiEcbW4dfKedcGbBx5+apFXet/kwQXeZmng4M9D1uplDK8AunZuR8ksKtlP0/Vt0kltn3npuQ/T5hUPbe8gW9ecKpOF7xc8W2j0WPohq2e5XHJ66kF6VwQrUu7p2nI9qS+cvxA6L4RryWhZQyoUVsa9j57JOruO973vfbMCmPFWxWd3DCAn8ayYchnLLHSxQfqepF7oZdmrbg0lW/bccG1IKbFoGnSpnJCwVSJtb/H4wzc5OLhNXnVojEPKpSLk4HZ4l1tUWk6OE/fv3ePO7Y/y+Nvfz9WrD5XiNM+nT6kDGwPSFWYCxWrvFBaJCVUl5AhRM1Yrd7OntY4B3Fr7kLBC98CUfgmF9nFhHCywihDTKICnwngd06CxrSmhKvhFlKTqnH0+HY7jimhd2IfgNQuqsRwnknMalICI0AThsbe/i6PDFXdvf4jtLLD/MEsynYKWwLfXEJRU0lJXcHp6ys72Nfo+0fXHNDES0gJCW9JxPbtLMuTgg2m3NJIUzwaLTaF+BEGwnIY7kePcCWXG5caF9gCe/fBHjFgEmaXS5sBrAvLCU/hUhD4IIXr6J5Lou0wMSxdGqSOJcv3mY0huObjzMtSgaoEUgRVKpkubM+3RHT704Z/msZuPceuxz2W53GZoi2/OI29a5l70VP4XBvqhCkZ/TzpjIYvIYJk2ooNAzhM6o77vfB7/M8N5x5hSQGvKoRSKeYwiETeMiqkSGY9b7q2kIdPJlVtCZYfbL79IZ5/i2s4j2GIXxO+Np8syeB+pF4wVbduyXG4PngC4t9P3GcsrLEeClfMvm5Jua1ifaK1DmitYfzpcZ4yRrvP6gi/6gvfMHsCMtyo+uz0AC9mzfsT79mBFIKki9E4jKIScoAsogZQNjQ0SGhJGT+bmQ0+Q0hEH949AnaOvwiqEQJIeNSVlI6dj7t9+geeee473vutL2X74Ok1yqzjnRbHKz1rXOWeOj4+JccFi4edwAR4IoRneJ0XYbQrzRoRchFgV/uM+60qgxgDO3rDijVQvpSi2YXNyqSOSyXiwua4dQBU0R3LKqAYwCBlASBoQwWsRJqjHn6bmQg1Kix8jjMVloomHbz7E0dEWL91+muvXDWJgqbtkwHJDKHEVGsX6hhiVk3bFzv42h/dWROnICKFRcteQyXizDCEVwb6QwEoBlqXvUA2q56HI7CIbPzNm/HzgQiuAJIGYelIUskayQWPQW6ax6Dy7CZXWyOa9YGrWyKKBhx55krQ64vjoZE0fhhCQLGRbYdaTc4cm4/ZzH8Z0ly/8oq9isdUg2S3aNvVeJVtaCzi0pCY6fbOzs0PXuYJoSoximpa5aXVPqZ3Oigh7AI8+RRX+Q4O3zftWrOSa8RKseBLBC7NM1IPh5TpqOwUMkmbQSmBRHTBChqhxEJypZD1FbC3YOm214ZXBoycTgpbYBuzv77Gz/V6ef/FpYmjRHSGyg0pLLwEEBEXVSkA60p90XL96hePjY1J7WmIeiRCkxCIibVss/Jw9oA4IQl8U64OzoWbMuHy40AoAwBZLggihb72ni0ak/ID7nDyFUNy17zGaoJz0LVEbrj7yKCerO+RjF1huPRsBt26zdUhS6E44Pj3l+U99lCef/GJ2d6+UfP6a9w6N1nYIuGFrCbfyZQjGikDfe9FZ0zRrArqmsXpK/noxlgtSj3WYilc6P+B+OF3kwixtHKNSJwOFIuNfEUCCVwgbQ2ZRmgSMRQQpysOsKqg8vE9L7UHOmWjZ70NWNvVQZ165rdk2aKyMGeRcAtwL5dHH38Hx8TEHd15g/5oSwzZSMqE6bWlUUVOaxmsauu6Ene09miawWq3IOSLlPSl5G5Cu88I2i0qUEpuQ9aygEMJQ4TxjxmXFhVYAGgKQ6PtJMDQlzxMPQgwLcteXXkFuoa76Fsuwf+sxupM75FVHXwSfd8RUcskcidaRUuLk+B6fevZF3vUFv5CtrcWQyz/QMUnJ2k9ol5K1Y4ZIpmYcqSrbV/YBSFIszpL7HiZsw4OsTzFDiuC1LENaz5SfNzOaUhBHuSep9BXKUpVBKRArCivpWCdQlaWYoKZl/RU2UR7ra3S56RlBXkjlwrQTbz3hxWGjgPUlbMQEqHEQb9YnEliEgO7tsdzZ5qVnPsrulQOWiz2y7tGI10tgAdXGg+4oR8f32L9yg7i8wvG9l8u9i6R8Qk6ld5EZIWeyOBWXSIP1P2ZZPeCLN2PGJcGFVgCeB1+s69SSlpFgBpIgZwxv9tao0odA7npMM488+iSkU1YrL/wRM0y8K6UJRBJimRyEF5//CLDFu77wy7yRmHjxULXSc84gudAllT7w9fk7dAiW+rM8CHw1yOU4D6JrhnOA99ofEn3GSt8qQCudMmSYSu1LVF9QJs4FttEjv37cOY+KoGbvVCRxId7kci4daZxpWmoWBQ2oTa+rxi68arny7tKv00OeQqpFESQsGAvd4daTn8eduy+SDk9YXoFge2hpVod0pSVGw3IpnBzdY7kbafYepjt6EQlC0AWxy6xiwPq+1Ep4Kw1yPWepqUgZ0hwDmHG5caEVQMZQ9Zz3tFiwJGBBMGeHycnI6oKs61aIBB595ElWHNMeHHv6qJnz3QhoIvdOFeXT+3zqmQ9z46GneOjmowgLcuHzpwLRSuuDDJiY27pmrihiGKpgK3VSWy2U5gOEEvTNQ+CgplvmcsxC+9i43QX+NN++FDMZIDrQQ6HSNHk9+DvFeYpn87X15yW/XwEdz9WgkL19gxAR7YbsoLrfVMBPK59DU6xwcdpq6g2ZGdKD6CkhRB66cYvj41OOb3+I+NACs6ZUWeNxgZJZFBaBrj1lsejQ3Zt0p3fcG9KM5lMWNf2zxCiWNRBd+hFBpmkCM2ZcZlxoJzjGiBHokwchU/Y+99k6jB7RTLO17Z0hA9y8+Rg9h5zeO3YLFS0WqnrevC1BOo6OjnnuuY/z0COfz/5jT6LSABlJEOzsLckqmBShXOiWIEJEBuEppa1DpXeiBRoiFiEHVyJVuIsYSXQo2KrBydrSQTWWtNFXF95ZfWpY0ow9QJWfl3Lqf2tw9bUhaQkQS6I2tAMIWZHJPRszisasoB7BQizXp66wrSgEGb0DST3BMjs7W1y7/vkcH7TAiTcCNynUXK0vCMAW3ekWy+aU5XLb5wg0kRDHBoG1RUjwdnaYedC4Dp+ZMeMy40J7AF3nHSFd6BtBldT74JVeI8vFktR3aErcvPU2Ouu4f+eE2BiWtQQ1KR0vT1DraU9PufvcJ3j0iXewd/2R0iStVolSop91BYphhFwzc3xASg2qmlA63zAUP8HYOsFTLscq2vPSO1Wb8poVFSFkG+sIpu+vCMXiz2FKqTw4tkA5rlqx12Wkl1TXWzts1jWcd8zp+ye97R7oWQzzDYbjl/WmSn3ZUEBWG/w1V3bYaZT7dz/JtWsN0LgIr8sp1CCaOD5KbF1fYP1VcrqLBm/617YtzUKxlOkNFiWL6dUyrGbMuEy40ArAu3xaCQJqCcq6UI2LLXIS+hx5+OYtMnBy74hFiKQ8ackgoHIKdLSnidvP/zRve/KLWO5dJ5a8e8OFWtiozRmKnIL4gaoQU1mzcKEK8zi8ZoNxOVr504KwYX0TqsQw5/dNx1xPE7e6C5zmKOdkXfifVwE8CHGZlL5NBPtQeVxpJM42g5uee1pFvHb8jfs23ec8GqoqghozCMKQyaMlmLy/s82Cp7h/8DS7u48UZTVes58sopo4uX3E7rXrdIc7dN0JGgMLXdJ3p/6pio9HC9qA+MjNuRZrxmXHhaaA+jrn1kaB1BPQxbZPALMVe1d2yAr3D54duHS12gky+cjFBOlkxSuv/BQ3H38/O1euEcToLHs8oAZhN4qDpkLSxKmgtU6dNubx1778Q9BxIpzr+x/Exw80EmGoMnaB5d5PXcNU8G7ivHXX/zfPO60/GP7XjOiYxbO27Rxr+VwlYeqWOSO18qD11oByCOEMFePzlX0UZLO94OrVx+lOXkbTCvBqYKM0g4uFSlouObp7yGJ/nxAa6myEoAs3GGRBoEElIxYRE7Du3LXNmHFZcKEVgAv8RGe9z4UNDYvFgqYJQ8Bxe2uHw8MXIW+XNMExXbIGdLv2lGeffZYbV9/Pzt4+qPPQwUYaws8XiiD3tMaKYJ6RqRpHwZhtLLAqmGa4nHct079TwQ+4ZUoVjOqB1vI4j69+kHV+HswMleixDlv3SKbHrfTLeC1n1332eqeLqDGCsV1DyNN9Pfha4w8PUkw1UN73LWKJxXKX5d7bOFjd8Xue89Bsz0wIEgkZNArd6X2aqzdcuGcjRIhh58y6myYSdJ4INuNy40IrAKBU1gptTiSBJkS67J0ir1+7yf3jA7TvS0MyJQehD7V4y7D+hBee+5c8+ujnsH31ig9SyX3JwlHQWFo1jJSOB1eBGCAGLOjQntm9EQGVUtylJWg7vZXnt0uY/k2M+ehO64A04vI5SEkD9QEoblnrmeO9FniG0jikRsO69V09izXvIjzYYxlQ1lTXklj3BpyfL/RZ3aUqVhsD3FNF6FlRgk0UgWcU9WxvL9neeoqj00OQFovQ5uSdQ61H4hLseA9DAAAgAElEQVSRhq4V2uOXWF55nI4O0UBcCCHirbmz11qklOYg8IxLjwutAPq+HyiM5XJJEKUXg1XHcvGwm+btKZm9kVvPCUstwXqOTk547tmPc2XvXVy5doUmBB8EIi6wMk7trNEnBMQyURumA0dqYHcUiiXL6IyQXA/y1gIt7Ky1O32EDJrVe/CoeO1BYBTY59yfacrqtMlcvWfDI7iQD9qcoXbODfLiIY8sZz2V9YuYKDrxHkW1GO08D2UYRg+D8vDnxWvSQEZIhZpzL8C/AznD7t42+1eeoO2OiOSSTlo8ldyhmskckDqliffRZp+cevc2QvSW09EftR/QjBmXGRc6CExQcucTomJcEJpAt+qJjbJ7NXL3zidpZAeTnizqwUMySEPXHdMe3+Ztb3snzc4+iNBnz8zJueTiC5DyKLJL6qVIKSKiZul4F1AXRGmggs6DSR1vMgpHNcgigA9OAXy+sIbBErVQhtmQSiOeAHjdgYnPxR2avZHPEbLr7Z3XhDwREUiSYNIPv5YmiMgwh1ik+AvDuTwAPSiBWn1c4jMkn9cr5vcoIMO+QxlbTcEv67a1OgdPSvLDFwVWYismroy6LlG7E4WtBaF9hNOT22zvXPV4QRrrMZqwT6Lj3t1jrt+4wcHBDn3rY0G7DDm1qCqLxWJWADMuPS60B+BN1ZrhB9v3PTm3hHiN0+Mjgu4M+f6RyFAxmxN37jyLyYJm6ypRvRXEMFnLPOukNvdJAqhikku+/3peew32aqGLHhQUFZG1JmsAJgGTQMBFukosQrQURRUaYhpwprSX8PPbxAspHkI959Ctc2P/MzfSqZ8wtHY+i6DNQBV9Ovj8BFe2ojbc180OpVXwb96T8iq1LmCzhmIIspeWHP6aezlmxtbeFXbCLrG9R8gdjdTtlVILNIst7t1/hf3rN5Don02M0QcAvdq9mjHjEuFCK4D6o93a2hkCvMutyM7VBksHaI5oSV8US+QM1q04OHqZvgvceOTtaPQGcGSf0Vtz0nPOA+csUlswjI3Cprn7HhzdEJ4bvPz0ufejr8895742egO3/EPNJjK38kUEleg9gKAEVPOQAupCy3CvwJWImQ1C9kG5/OO+YDgVAqAbbZ3LUc7ss3md2fo16sdLrAIqccz+KWtX8uQ6xljGeRlG9W8IARNFQkQDSKhV2IGuZHRFjLD/MCc5onqKiiGmaAkyV2Wg0nB490V29m46RaY9zWLpn0efiTrHAGZcblxoCmgR3GILuqBfHTqloNc5uX8bbIlK8pgAEMwQek7bY15++SXe9c73I8FTQVPNtS81XrWXTh1uYiV+MHLdufSwfxX9WIVgsebz1PoVGWsLBl6+CGYVglghdyCG6Hx73TUKtKcTr2OiSGQ4fPmnPp8GWsfgckWyTCCsnVOyD1R5kDeDCaoyeCAZt9CT9aiFc2cSmLp6CqVjaEXM0BeKp/ZSmha5ZQJqYNad8Ygg0ktPyj3BFCm9fJYhws4tTg8/hi4yjRgd5q0jRAnBO7WShIXeY9XsQNsj0T2s0GTaz6ASesaMtyIuuAcQ2I5b5O4Q1UxqGvb2hT6XAChW7M8yJIUV9158hic+591IE53fz+CZJC74k0BDpCH6cJkw1YHr3LSvYT1Ye2abmufPkxDrh/fVVgQiQtMoISoapASgi4IATsUz23uc5dZaDzw9V/EERD3/vdYIbK5pGgDeXGvbdWg5Rwu0ajSNEoMQVPxvWN/H++/4eYP4NTYBr00IviYPFnuDPnU1MewfQiBLFf7jGjcR1YZANaxnH03rGHrc40kplXnQAd15ipCfJ4sQpn2UJA/ZWffuHbC9d42eNMY6iMQ0ewAzLjcutAK4urtDNp/9Kha5eeM6h4eHxEkP+9qX/0Q6XnnlJW48+QXsLW9Ab5iEQehbGLNikmaSns3hN5NBYWy2V5hmA21SGB68DaWnkKNZLlgsXPiDC91adpRxQXxeN3rRs4Vaw/nMz7Fp4b9a0dZIBZX4CCUWgdAV4WzBOXQVfE6yjMxPMh2ymCSHUhBtnk4prnxJZ+kkVSX1huZAJsCkzsHrEfxaVBpXIpPxmn3fn1m/qhLxTq319SDKcquh4ybCEUoiSkatJ2T1MZFB0bgN7Ussdq/TIzTKkGk1Y8ZlxoVWAJ1OUkFj4P6dT7FQIRKGNEURoe97uqOXiYtdtrevItIC+PAXY3jEPHaidKvSrUVVyLnHLDH2vc8I67GA8zC0jS7pnmoQF9GFJ+rWNnDW7nWEjUfl4aeexPBcM6L9WsHWg7KRxgZznr5aKapNkVdDuC3QlfcEDa4QFEJTitCCFo/L8+jRyj8lYrNxb0zBGohg0YglOB7UmLa1qI3l1HwqWV3zlAaq9QojW+PtIlLqWOUWVVjsXyMfZwI+jEc2v9YiHK16theCypKejMYFmh70qcyYcTlwoRVASCuCKFEDW1tbBN0jidJZ9pTPUsmb2gNeeP55rl5/ByKBbDJY/km8hUNWIYVxmpbzzzrUD6gqjeigIDxdcZz/uxlUTeKEh0nEJIJ5qmWzFd3jYN3Cr5TPcG2MSiEwegWyoSo26ZzaMbSuww8eoAys38zbd28heDfM7DTQBpG19ixPHmlYt1NdFpVMQz/NkiKQbN0rSprJOlZlVwqrxgykdBX1YPaSoWgs53NacZd9QqQvjfgseA6SmkKf2NZIc+Uxjo+PEVqS2tAtFvEWF1jg+OgeW/v7aGdY6rC5HfSMS44LHQROPSW/W2hbt/aySKEfADKdnfLc88/y+FPvowk1U8ZR0yT7koMYso8I7HIqQrIKPxdoSXKx4n2wynnZNKmIRC2Mc8ItcjKIxHNpHcqZqs9RocDYjCDTMs4VWEcubRvGQq6c81rfINXFuecdPZiAJO9TZGUdny4EOuYduRLYUmjFO61Wl0KnFr1HgT0grw8euj68LgmRMlyG8wvIaqXykJmV06B+aiO5lIy4m2j6GzTpBDSScsBQRF2R56CkBIt8n+PtHeTkmKZpmDHjMuNCewCSjaAgi2rVqjd4cw6CbB0nhy/x2KOPs7Pcwa3gjOXeJ3KxnqmS1Dnvsd9PFUYuSGwYk/hgTr02mnNJp0NK5pAX/yrX8+qMsw4Cea2Kt8Qmzq0/KMFgzDn181pHu/AUcu4LhePYFM1V0CemQr8oLnMvZYV/JkoarPj19dRg9bR6euMtk5iG03iKZBu4/fMw7ZgqQVlnbjzAHy2wtXWNu8ctIh0a3AvIpUAtmhFIHN8/YG9nH+ISy3MzuBmXGxdaARgM1m4dIlIDtGYJa0+4c+ceu1cfLzndLgyQQI/R4x0/JWUPIEptJy1FsCZE0nDMB/HpcDZfvQo7DZ5W6Nk9YG2isZHTXwBbuKu1zvU7pnLPbXjFdKwbqLUQa4NgBChBbTEg+NB7lWatiZxJRGMEjZg0hdZ6dWx+IVI5XzIIRd5vdk0dYGPfoel9O5NFZd719PwCsfMxBr7Xm+3V47bJh8zvXr3F0dEBoh2YELKiaZIdFZek9h5xuVe6zc6YcXlxoSmgELwvjuLtA1TVZwQYpJS5f+85Pvep97mlbK0XevV9mUU7phSmnMmWvQoXJZLJKdFIyYfX6fjF8zGOO3REcbojMwYsc86YVvqovG/Yw4fJ1MHqVQmsZDxrxpVDDOsfS/YRuwTx665ZN70mJAgqgooSNlig8bhGjEqfMqnvIJ6lPqotv8mK1+cq3j+pHnPIfprSZK81q2biObyWoTPD9aiSkyDSkWuqbaW4MqgYy+Uu7eoKpA4LAc1hLZCuqpyenrJ/9Rr3VnMQeMblxsVWAFsLcueCt6fDKR4hYxwfP8/hkXBrsU3lgcEnS20admEyp9crgDPesmZd8D/QA7BQkl7GcYd5Q1ROFUTO5hO4tIZma4HUeK4K3fi/0jAbLMf4PEHW5JazKUZm0SgdZykmWz+EZzVJX8vfwDsPAWcFv24UetlACJXnm8L/PNjGPZLx2MBQy3AeHlTNrMGwJEDALJMke/C9xkUC7O4/wurgJYKlwfPZPPbx8Qts7T7x4LXPmHEJcLEpoH7SM94iOTl3v2qPuXPnDk++7Z0AZ7jvscJ0PRNos5PnNC0Uzqc2vDdPOse6Pdt6YZoxlHMm5USk0CjlvWnjwcbr9f++PKZ8vPeI00kdhDd6y7x6xhEIHS7QkwX6fty6SUnVI/Ti1sHgSyUvBKvXO1xnyYSqsRDfUIoLSoxi6CxK8mPU2MVrwHmB4Wl8JBhoNlIqzfRSTyPQbO0SLOPzi9dHUgZtSD3sLA5e0xpmzHir4kIrgJx9+tOQxx4UESOfHHHtoSdY7GxPLMV1brhO8XJ4w7HpbFpVpSvpnK+GTQFUhRmlMnaTChkViCCESYXvzx1VWGfC0D5Bq9LhrOA/k4pahtsbPc2ZhNMpZMgUOm/dVfBnXMiLecTFN04TXD0T64wQt8joGz0Yr+YdnIfp/Y+Laxz3LcqKrGmoBUGSr9WU9mj1adcwY8ZbGRdaAYQwJkkG6b21gyaeee6nuXbtqnfnLD9s71NjY564bvbyPyuIzm3tcM5rU0TRIXg5Pe7QxoDkbROMV81sqaiWfwNcKX/PCxZX5Mkxe8tD1o5w1rvY9Doa/F6pjUpp6wHnmYYTzEalU1GteR8075RYLvejKkmTuNZqw72VANKzyT6uK4jAtAHdg6CqWNChynu8RxnRju3lDVJKYP596DF8ZKUH1Y+69tOeY8aMtzIutAKQabMu8+rU03sHfO5TX0YMzv23OY0/bl1v21AR8tg2+bWe1x9j1ooHkHFhUmiPagEjaQxmFgEj6gNdXvM5mXoK9uBWESIgiZPTw6G1dMrnVxrrRlQgl146IsKyVkQ/YD0tY70AlH49EwpoGEazafFPlaikoVV0fa7T5zbOQF77zCrlVrdvdCRdL85zz68zzxRzL8DPK8tt+uQtJNR6Ah2azYPmqmuzi2fMuIy40AoAYGhGRkJyx51XnmP32p73gM+JYBnNpR/9RtWuCyNv+JaDIX32yVvntHVYT/Pc6AVUcttVFVEjDLNvk3PjpTYgIGMKZwiYeJB1KmY2LfthTgBjJYBO3lMDwg2eDdTl5ENyNNCn1lNQ+96V3OaxTWmKXDWgQ0ACyZTjYv1O4w5ThROAaCX4u6GILevg9bSpJ6WebB1KoVcqEVUFeLlXaaKAXhMkkTWRNZN1VGbrTe9sGNhjZj4gXiLSK1sx0DRXyOlkVM6lcV8wWMztoGdcclzoLCBvF1CFRebk9BWuXr2ByhadJqzPpR4XJJVpX4OwGtNAvc8P3h5a1rnvV6OEKlS19OkvU7fUGFo0a4BJ1bBPxGJI+KxoyqMHTlgX8PXvsmTl5HLVQp0LVmbuZqFB6VVptpZI0oH4z12CWEYfln23S0uKyrYHv0hSTsN9W023lXVEvF11ZxBKg7xcgrbejXS8rhgjZnmohai9h9QMKd7BQB3VWElpJJdr3/5yLJM43MMafP/0dQI1d8rvdijZYBaculrs7HJ49w4Laci65Q3iSkvqeSDMjMuOi60AivVoZljKtAcH3Hjk3Yh2WCq8f3lrPkd2m6XCmY8Wa8V5zdYqqiCrrY2HGS3iYtlwi7/vx8ZsuQjbMBGUynJouVBbMVds0ju1m08NvFbh773pMr1l1IJb5Nr4ysLYRTOboVnJZsToC64h9KoQMv5P32VvW7Hw58LZkGwAupQRcQF73pwByn0wZOD/a0zAJkVnVYjX3H2RVLZ5/yRyKIo5YRhWaKHahVTNK6+NVIbqjPGV2u4j1QQkmXxOJsSwZBGvIXJYmvvV6uqEMLeCmHG5cfEpoII+3YWwh0Yh5EgdJzjt9lmN/9pATcuM3yq42nY96DeOEFwX9GO7hxLg3TAUfXiJ9/uvNEUN/tbza14ieZ3OgQdXBA/HxmjwIGxNw8y5H4LOVTHp5FqHjqQly8mKeJ16IDVVtDfvp3/v8Dna46NB8ayvwa1+rxz2dgq1unjK2wOl6ZoNgXEzQ239no2D64vQrsHgeoxCm20e299c6bY8fBbrIzchBxm+A9MmgEl8glmze4W2S+z03hiut44sSg7nRVlmzLg8uNgegPd8JEtmdZp46OFbsAz0ydAyqar2hRmE98TKH0oISn+f2vzrbFpieWPN9S9jCGtzM8Vn4JqU6Vg6CjgRGRWPhFELlSBytf7b8tdL2caJYNMGceLty9YEtzMaEUr6ZlbQHCbb1/sP5ZzJddCJedwgkBBRcur5pq/7dTz9saeJaty6dY0f+OEfIsoCXcZCi5T9zEoPoehrLB7OECuZrMHpmjH+YoXakULlqLhtH3IR2ApBhWypWPhj5tA03KC5KLfBcyh0j4wKpU5MSzJ6BGo9JoE+9ywaowkNKktWoSWzVbwqX9eMGZcZF9wDULIJpJ6uVQi7pQiqNixet10HYZyrRezHmBYuTf8fskvKzFrLPpdXzYWPtxK2geIZVmWMxU71GKZON5mAyTC1ynoj2WbFrwwxgdoryD0CKRQIWC7Cvxqp56RFqhkhn6VlcvahKqtVR9/3HK96jo5O+OoPfDkvPvM0Ibek/pTnnrnLr/jKX0bbrTg5blmdJtq2Y9X3pJRKdfU48evV5GWd1CUikGpQflRltbK40m4p2ZBBNCjv0mSu9kAaPlPxOcpT4V+3Qc2ZAsiYZFKp/I4Y2YRMYrm8jvXZ50Ofl3k0Y8YlxAVXAJBI5P6E6w/tswiKpEwwdavYFtgwjapcigY0NmWgyXqLhzpo5AwK9RBjA8ggmDxzxIV7pV1CEVh56IYpZXTitI+9/x0omd6rgrNl+t7oe6PtjVWXacv/P/7j/4BskEqVbso9KY2Fa/X4lWYBpzem3szQiiLhlrWOnU37DH/+O/8c24ttsgl9ByfdMUeHPT/5kz8xrFUIQ5XtsH6D1Oma5b32GaU8psrWbqrZ6PoV00rgivPqLTbhSscVcKWBpplA0zkJtVlepQVBQYV+MptYG+W0W4GsvJMp9f0zZlxeXGgFYLSYCffuPM1ise+ZJjljlgarPYggKaPJJ1XVYGW1XjctyTOdKQFVH4Au1jOdtZt6qCkvtdhJJaJZ3UMoqAFmTwjKg0XqKaS55LR7JtEwwzhnmtKqOQThK77iK7zhW/COplIKqLIYWcRHM+Y8WNmmQtAFNpmje15TtpQS2Xpyf8rW9h5Pfc7b6NrWxy5m4c7hK3z77/h9WEqk3Pns5N6wPFY2WxaahWB5Em+YyO8QApKL51KUYdudYFnoWp/DO3ymE+Ux5fNF/B67p+NCvwZ8vd5ACTa2m7AsQx5/7cPkHmBGbKI4s/n8iBDRxTXEQhlwb5jN7aBnXG5c6BiAKnSn99m/9nayhgk7Pgoik0A2j7b6PF0rdIHjQd0mpxiyfCq3XxRJlJKZL2OlVc5TryIM68SKJxAEy0DpQ29S6QbfP2EloBtIKSO5ZCPVTJvKg5e0FheQNQPHEzS9ypYh3b4ilAylVAVoZijYCqFha2eP5154ge3tJV3q6fue7cUudw8PaduW7bAN6pk/a96FuNcytr0Ay17SFSbc//Q+LxYLUl8on40g+5DYW+vsyrXo0LvD6TkNkLIgqiWeUAPT/pmYqaeSMmYFVQyxhElsKG7tYu0rpUBuvXXIjBmXERdaAZgZ6eiQ3eu33AK3RJDaBdJ/5CYgYZ3qOY/zP1cJBLeqlYngoTYu88Bl3TJ2sKzDSWIJQk7SKKVMw8owEuYy5Jyrjmsww0ca1rfaaMWLmbe/Fg/wJp3EHajxCz/2mGI5poSO8YI8CPFsmW/8uq+hO+7YuXaFJxa73Dm8y87CeM8X/wK2d3fH86thed2ydiUSvH7AqkK0YUj8cLXFc1INhDDxTGxMr51CxAu4c9muxnifSuxEAkMspAajtXgaWu5DNo9gJ8tDkzjwYLZHwjONCsenHYvdbTRncpyDwDMuNy60Asj9CS/ef5HdR97pVlvKPri8CEw3GEevYJrbP6V5xpYOnmFvdYxjrRaavCeXYycm7Y7r7jaOJzxenXpWURHcsaZOUoKSlatXRVWIE+GfrFAembHOwXSNthraPUsu2TBAkLVeQNPcfDVI6vUA1fz1grVSJ5A7fvNv/Z38f3//73Ht4Uf5mz/8IxycnKDA3X/2Uxy98iJ71x8ixoXTP1k862YyHtPvj/k9LMcdmu6pF5ipZQhx7EM0jN8cA8DT+z3QRoxZW1OIgGa/LvcYvAOqyDivebxWI9AwTnnz70hfUmubpiHEBYGWLA2aLvTXf8aMNxwX2gdu25a3Pf5uQhBPBQzRe7mc02StWqnnvl75e1U02CQY7BO9Khc9NHnLtp7HTiAXBXP/6JCMCxO1kvpppSAtjJkudaLXJjJF6KUesX44Vw0ynzclK2vGQl4TeAB93/usBPNCsSFjplxD6sdMJ5PIV/2yX8K3/Pb/hPd+2Zdy1K1IKbFKmTv37vNrv+lbODi8W/Lz9cz9HAR2UQ5D503TSeqmV/2m5LGaaT0FjPx/HTE5ff1clk4m8YYgRBHU7Mz9ma5vM75T20VXRdksdhG69fbVM2ZcUlzoX8DRvfssFvte7F+suqzij6G1c+mis2H1wygUokITXJCuVQzXrBZdT/Mc+vmUY4Y8CuWre1c4PT4mZE8DzbnQNTh1M+Szlzm3aqOblYHcmbsAJfOoKpehuRoMPXNqRlIV6FWApuRWtcYFXbK1jJiz6ZOe0dM0DdeuPcTDjz/JJ555htT3kywf4/nnn+dP/fE/QduecHJytBa4LTeltMNYv7c1MF8fpLxGwZmdVbBZoJ9a7yJMddugBG1dK0yziTappM0U31oINuybMyKBJm5jqQPrSXrWYJgx4zLhQiuAtj8mBRf4LuQnll1oCLp0Xro8HiT8gDVBBCVl0ryrZ0XGG53VBnQj7dGXoKPRdR1N02DDTOCNDKMkaG1tUDyBOtwlJUovnVG4uqKows0HmautD0nfbMUcwjgAfnp9uSsts8WbximZUIrXNMDezkP0q47jg8MzQVvRhu//Gz9EOr5P7apas5hErTzy+Bcd6CtgiBFoE4d7ncxTMbtcGsGFdUX7oNj8ZtroFBog69h9dRg2s9HmoxoGdRhQLB1hJQptr6gk5DXMJJgx462MC60AHn7obWv56N4eulptGaMbrFIRL+LylgVjeqC/s6T+lXYGyZSujFZEupHykQ4LGUmKJB0nWBVUpTLWB4RzctzH/80MTZ4QJF0PuRter4+u68g5069Z5OP+4AVSGs7jPVwgD8I8eD9OKAJRFyRbb8+8jMZHfvZnuL5/zQW2Us5/TN91fN/3fZ+vg3Fwymj517RMK3GOqpQ8wJ16V0KDdyZ5yIYCyP06b5/6UrPAJCYygQlOA9VHfdFqSm4Y0mpzf3bO8FTBZTqwjkaXmGyVdZxzT2fMuESQi1wNeefwrsVmOQjLdU563eKvmObDB20GYTpYizkTq9As5MxgTRbLctrm4bw00s3Cq/qaT+vCh9Dndc5+4MzL/zmVzBpzwZXFKYoQF+SUEN3wagw6xn44MGbp9FaLxFxZMvEKqiBOKXF4cMrLL7/I85/4OM88/bP8sT/6pzg5XQ33VUS4+fAj/N1/9A+Ji4UHt2MkxJFamV4PuACv56iFZEj2GMREGYWwPpxdRAbFUrN2h88trN/vNc5fRo9jeo31cx+V6Pr4ShgLxu7cuc1WWNFLw8P7t96sVKCL+8Ob8VbBp/1uX2gPQGjO9O7XbARjTZgMMHUKxwIqDUmSB08nHP80E2WYXFW3JxdcNag6FdjnCb9N2GT7mvU54dpTb24Jp8w7bl7n6nbD3YNDXnjlFb7hA1/KV7//i+j73r2DQp0k6em1Z7FwheCTwMZ4wHg9PhQgW0dtnla9FSGwvb1kf/8a16/ts7OzU2oXfG1V2SxiwPqjYc3eW6gI+hoA9ptG6g0xn5VQS9zq5yBSiuYkYlnIaZ0qW7tvk2wmESGl0QsavwxGVjtDDVWvbvP7oEn8cU7SQIwL2pNTyEtmzLjMuNB5cHFDPakqeUIBAdRGby4AEl4IpuTcoaZl0lZfBOF66b+V12tztRxKDxlbbxW9iQd5BJlJkdMGn+HVyalY/kbWFs2Jr/zSX8RC4OU7r5BCA7bF8YufZPuJd7Cw4ENWkscyus6pooDQdS2LZZ0W4NZ1KH9jbNas+mohiwhXdrf5wX/8E/yl7/pOGk0sQ8NparHk3sRpd+xjHCXXHExyFmKjLsSLOa7J8HHKsbS8trXz5fJ/Sl61bRhYU7yWs4bJZoqo2Uin5Zr6C2ClHFADOYOKD8Uc+wmVzyLU45U0WRkzl5qm4dQMwhwDmHG5caEVQN8oYeLqr1Mvm0G/kf5JGFI6ekbxAGCxl0EglSZuARsKlPwkXhcgcjY75NNVFNc9NrvLTC1pM0P6FSeHh/yDH/9R3v3U53H/3klJe1kSDNq84u/8+N/n3/l3HydteSwiJfcIwlIJjSC9sFgsyjmV1J7681KxLGksbsu4l+B8v5JD4Jt+3a/ny77yAzz3sY/zP/zZv8AHf+ZDpGRoqK2fwxhczoIGG7j6iqSUmoRUBuZM1MBQN1GC8L17WJoSGsLgnQz3Nnt1rwzdW8+516XF9PBZ5VQ6qQYQ7wBa91XVc9tPOC2kaBNRmWcBzJhxoRVANBksyynciqzP1quAB8rIxtoADwBP4gQ1oFyzcar1aFWErVv/WUBUz7C2NR1zTZgx4cdrEHpCAf2O3/o7+Jmf/BcsNZO6lhADd45XqMKWKjux4cu/+quRAIo3kYvL7VGIZYPCkWs5dpt6jg9Oubp/3ZVN5eMlE2MkmyDiE8VCCGzt7fJwf5NXPvkM3/4d38a3f9t38O//um/kG37tr+Gxt39uaYpXLygU+iZPJqO5sB6az02V9EQFipShOY0QpLa76FHRoWp5M23X8qgIznzuU51Qqrgpg+nrRzN4HZv7liwlgGANWRZdxeMAACAASURBVJTttDrzvhkzLhMutAKY0gJnrcJioRb+fpgQNRXGD6Jwav53oYRqh82sUkp516mB/5+9d4+RLcvSu35r73MiIjPv+9a99a6u6uf0eB62x+MxnsGWPTM28kMaCb/9h82MBgkERjIejD0jgRCyBUIyWAaJMbJBwtiAscAWlhDIQoYZI7en3dPTj+pxd3W933XrvjIz4py99+KPtfc++0TGrepBNGTXjSWlMjMy4px9TkSutfa3vvWtMuZx24pDMfhFjKCipYN4BO1xKUCCISoXOuWNr36Jblyz6BbcDgMpODqBA+lYHBzxV/+bv8byYFV17jUpd95/l6OjI7xbcHJ8zOro0DJ6tb7Yg9WRnTPvcNr7NgxD3RkVh310dMQLL7zAM5/99Tgd+O/+9t/iwsEh3eGCw8MLOwvsGkdEuplU88zUZUaRyWC7KpXhKF3D7Xu66xgFYppYUOU1O95EFZwYDKSCCXcU1tTWDgDIw+CtA835RPI9Pg47Dry3vT08dq4DQGttZ2qhhjrnqnNuM0CtoLHO4Yac8adSC5DZCSqvfdvffBD8k8SccATT8KlspW7G9/fdyL/+B/4Qi2FNdD0nQ+Aw9qwJXLpwgb/01/4qJ2Hgws1HOTq4ZHTVmKyB6/L1epyLFy/Wrt+EElPCd35WcxA8TorTJwcSSDoQU0RH5TOf+QwhBKOhXg64rjOWTNcZi0iN8qrEWngW1MZSNp2/doPyt6zQ6d18FxBTds7qGENgsfzgj90ULMr9Z/Z7axZ0QPF1t6hMMJ7LmkYtM8o5x2F/wJhOP3Ade9vbR92+IwJApQ3q1PlbkJ4SGApH3yiJ82LidrG3WDuIBLBA8msg59WAVHYCPHjXccH13AmBjV9wGE9RB+tD4eLiCn/xP/tPuPzIJZ699gh+eUjXm/pZ19nIyYkDX9RHXZWBmHPdbaKYUTJbBdNkDWupZxgGumVXj2VD3XXaQejWLiqrcXZ+Yawhzu60JoE8LNhsMaZsToA9r19sFeLVILfpOO2u7wN2APU9sO9ZCgh1c/guIIjviFghunzgxa0Y474IvLeH2851H8DxuFFCJOqk8riN+bfBoWLSeay6SMbRMxNkmwXkiFWBslhLSWwz/10SEzAfOlMombNmpxj5Z1/+Kp/6xMe5d3rMb//e7+PGjRtETfwHf/kvcXDxMtcfeYyLly/QLy6Aa0dXThz5GX21aXQr8NNq1XGyCWfWPHPGyZz8jKGkk+5PWyzehtvEBVSt18B7j9ZeCk/SQPbwzBRLG1PV2rRGPkYrJ9H2BYBBQc5NASDGokxKfUy1CQCU3VtndR8d827Mgr/XTBLwJouxOVFOj1/g5o1P7fsA9vZRtQ/9bH8HBAD7Rx6bZU7Tn6iCa54JmzYN/h3XLtu4cHakzh5vp23tsllmnM/bFWesZQziPABUjZwwMmwCd+69TTzd8P47b3P15tPQOa5duwZdT98tca5xjBnCCiE7sX5VdzuFVtrKNZ/pmcjLCJpmBdup+1amcYrZcY9BcF5YdEUJdYux0zRegfVqlKar7Xs17dhSXaP90YrTDxJjK1TTqbA//3tK2gT9vLbckFZF82LRJwp1veXLe89mVNbvfpNHn/z0PgDs7aNqH/rZPvcQUBSHoqYZv8WtFxEcU3NRrPBEOpPtw+QQiy79g/RmdrF7YIuKWv59yw8PCB71OAmWS8+l5WP4kLh0/VHTFPKGvQv23fB9rbCKUxg2keVyOc3cVc8Y7tP55Vn205YlodYDJqinyGFnyWcmSYa+z7uYTK8s1w1WWzCcRRmGDavlkRV43SRtoUlmmX3t18hHUFW864hBedCEzhrIK5tqmhFgs4QFJ9B5q70kmwc0U18tn4kCC3otInPJBKWlI3Xn/uO/t719W+1cdwJvWyvuVtQ0nfS1M3VmuUEIzkosO7VGplbrp3Xeu7pVP6gHoHQNb2f/xVRNCE07x4oe73r8ckW3OmAhHofk6yprSnTi6q6mit0lzbo3G5Z+Na0tK4+WjtvS0VwUTbcx+ZmDznLRNWPPXcOtwqeIcHJyghJxMiIMeBySR3MWGMoprDcn+G4+T7lZKEnnMNUuO7tmc/wp2fvgO8DDmOb6Qa2UdxJTVY1biXYUZ7RYF3Du8IFr2NveHgY71ylQm/FvO41C5VSsI3U2hzcPfjlzvDLCkYhKUwRuu5egct+RaZjJg6Ahmyi2xULKTKDy2sJaEhEQu47Od7ZrcRDDyGq5yA7YunmjxnqcxcGSmBQnwjiO9byakk3HKnCMVzQlpKiFNll/a9sFXHtudzYwlL+PgcPlCg0RvEeTzS62Pys4sf4E4Gh11EA95X66+qumRGDIdY5vLf+wdU1dvaVLuOQC5XQGAdnwGJdKjUBAhCgpj9ssnxOHW+ylIPb2cNu53wEU7Z9dPQDFtgMFknJmnyGExtm3v7vkkCh1N1Gz+C3J5jPHZ3dmPVv3DkhGVQ2m8I533nmnNicdrI7yOQvNNc8J6Dq863NG3+gJkRCB4/UpYwrEaIPX02gDZmKMORO2r2ItfFW0+1MEtEMZick0hIp8Q8nuDVoxvD2lxJgiIh5VmXogck1CZH5fiq4ROMawoe97G6bzAMiKHV3YZe3OWWG/fBRSahlCuR6gHuc6m7EgfmKLKWhMpBjzbiKxXp/sXsPe9vaQ2LneAcAksVCsNCm16pIFZxdpHLG6KQMtzrytC6jLBU4y93OrIzVnzsVJP2gH8CDYZ5uBU7BoFeszePzxx23NGW4RZ9cUiaRkdE4dLdUtTU3l+mQMXL5+kUeu3eDmzWv8g1/4R3TekxBc3yExVSllEU/INY2UEpvNhuXSMl/blSh5VL3NN06Tsma5DlDrpo4CElj4jhRGhmCzEVJKSOfxeYclYnCQukk+OyWTlrZ5w0Ii4WTaZZS/FbZPuwa7x6YSWnsCMkto6veyeoBTRVXwuEqLTWL3UVXpEKsDdAtWqwlG29veHkY71zsA1YiKmw2GammfBl1M2fv0QkeSphksQxA1I86/R3XEHAim2by7O4q/VbZU67Ras1EGU8AquH6r6T8NYXe1gDkMQ11L6bLdpDWPXH+cvlvwJ3/yp3jvznu88tI3eO7mI/yn/9G/T9/3iJhmfmquo+s6c/5xkqsuOH+M0ZRKUyLGMNE5S1OdJNTHeu9DihwcHACah8VPQVmD0UKnTmCbH9D3vamKFuZR3mXAxPzp/CTRXUZPFmvx/qkpMP+e6bzJJRKR5GyGQvnsbL8vFtj3ekB7e7jtXNNA722OtcLJNSv3k1NRNYgEDKuejYacIfP520T3LBBQee3UwTuvN5TzFme2U8Jgi4K5S+dGY6DrOmJZkvq6nu3zppiLwl7QMAWmlBLHxyd84R9/jn/5p3+KpA6ScvmRC6zfu8M//drz0NsOyUlXGT6ng2X9xdE7hePjUzrnWW+OcQr9wZGxkfwSSMS0YeE72xvkjus2Ky/r9d7l7HzaXSUXsyy3y7IMStIBYuLg4IAh5Ma9Ok9mvhNodwTlPWjvzzb2b3+0t1k0VEZYSgkXI1EhJWucc4hRUJ1w794dbl55ZE8D3dtH1T70s32udwBw1uEWh9xm0FMnquTsuVxW2QVky6yUwo6JEnPGmHcC9Rxnsf02EGjcGpauziCOsmo3sWoqfOPN+Rco5qWXfxVoMfKW9553KGlEvTVQWZCyLP7Jp58gZubRqJFvfv2f8d///f+Rn/mZn+H27duodGhzPSXrJ5os3nq9RuKGf/Wn/wTPf/ELaDzmzbde4t133+X03i0244DgGdqxlJmGq5SmL814vA2NKZpMSaja/1CCW64liOd02NQ6zRkra569F80Aes72BLj2rW7e43rI/FkoAepBDX1729vDaOe6BpCECptkpnfNAsdMXHfJW/EvBwKDrHezgMpjsywW8GQnRcky5xh4i+erKs43DkbzvNx2tnDeEbRww7Zy5tNPPzeTsKiD3p2rDtQjpJgYhtgENbh/uqaTBUNQHI7Dw2v8yG/9YT73+S/ziSef5v37p6TeUuLSO6Au11PGwJA2/M4f/m2cHG/4hV/8aUSEw9UBCeXGI1f5E3/yj/Jjv+N38sQznyDSGXyVqTeaHNLw7VNK4B3bOx6YYJ0wjrluY126MY0435/ZOZ15t5pdGJx1/pAZXFp6O0CdI6nSVo/s/cu7LEngOkQ8KZ3z/Gdve/s227n+DzD/UeQfsrTyFqPHOcP7peGAO5Jh/TLuzPJccrUL2GrAc3x4V9ZfbOponTLbVva5rKnYDBppxkTOse2p0JxSrkcw7QwWyw7nNU9IE1aHSxYHHc4nnE/0hz0pKJ/8+HO8cfeUKK4GzrpTSopPcP/0hNvv3QLtc4OaFUqPj485PT7h1Vfe4i/+hb/Ej/0Lv5f7J/cYx5EQQlOIbjp88zo/DM1oWT9FAqL0HFTIpzCgmrdcUtNgttUXoLnxLuj0eVDN9GCJoH0u+ifaTuXaQa5lxvTe9vbw2rkOAFCyvoQJwE3L7cThFILmiVBeKpRTi5/az5k4uSFMXRmePp/b29oHNXWB4c9GtdfZDmE7GGx/b4NLgYrKbmG78Lx93uQC6hzXrjzO6YnN8g0pEjcDX/7q89y+f59erJHMIxX2KbuAJEYxvXL5Oj//X/48Fy4c4jtX6ZzOOUIaGcZE7xe89MprxDQgLtW1Jh1RgqlwxnlBfrtTe/4+ugpl2RD6AG6cPUecok5LbD3TqZ1S7gSGDD/t2OWpm+orEjFBuV0f87yGve3tIbZzHwC2nYrP02dDElIm+zms81Wc4rzWf/7tzDQ5Y4ckHXFecepmXaMPsg9iAW0XKIszFImgfvcOZAsOGoazuvTldSEEq0+4HqcW+PrDBf/t3/6vuXbtGp3zqHdcPPRW3KTZtXg3E7tzznF0dMTy4IhnPvEcf+W/+M/5uX/rT/Hpz3wC33ckFFHovYMw8j/8zb/JmHIznERimtYZ0xpxyWbyipsVyM/SSKnXm5JJXJsWkN9ZCxCnlS66/T6URrAHxZrSDTzZJEdRjjH/29729vDauQ4AE79fUI1V2Mtgi4hjJJbC4xbdDwwKMrc2b+wSOjROmL1T8E3GGYWZrkw57q6sXDVWiKHN4jVnobs6cbeHlXRdxziOMzXRApH03ao6tbJbOPCepz72aX7pS5/n8Khn5Ve8+f49oz1yViY6umn9IkLvPToKzz77LL/5t/8Yf+7nfpYLly5w+9bbHFw8IqFcuHCJn/iDv5+FW1ZW0gzn174+XqQ4PCBhko9AHeMQKfIS3vV1YphwtrfiDHW2BgG1YNPUAqwnosX5AZRAQH1qAkGjIKtYU2GGj3ZNDtvb3h4mO9c00ONxo+WfVHVyPg6pTq04Jo9UGejJFMcEvWjuZHViBUjfZJ91Zq9CIlojFl3NUMu54GxtoM18q2BbYy+++CLPPPcswzCw6hdnrrOtC0wql5ZVn5ycsOgPZmssdM7jk7u8+uqr/Nbf8gO8+/bbuNWVyskvkI+qIiGZXIMqITvNGJT1yQmqyr1791ifvMH7t074P/7u3+F3/5E/xoULl7hx4wb96mLuKyi1DHPEZR5B13UV1y8B1Poz3ITruzK+UXP2PhW/y+QzmIrG2yZIfVsnNpCQkuK9zHYD0swGLmqgwEwOuuxQ3nvvHZ5+9Mk9DXRvH1X70M/2+Q4A4VjDWBzsnBoI2bl1zfQpPE5L56c5Ifvd/m7DTbRm5qiv4wQByMPXkzQ6N835Wmtx/10/+yxcFguzcStYLJdLNpvNzr9VU+PYW6HVrDjPlBIxTAyjGfziiuSDMYEKCyZpqFLZRQqiZMJjWNt6xlihoq7r0M5laInp+M1uwrsFru/qNfiGeVR6CLZhPHstteGt3rc6b1jn7xfY+1Seq9MksPl7AqRJbK4EynznUNUasFSVd955i489/vQ+AOzto2of+tk+1zRQEygrO4B4JhAAECcq4STwJhTZhxZGbgeSQJ4ENmORWN9A0cqR6uwKA2Y+6tBesxvGiK7AElu00+yc7t69y3K5RNWGsIRgTKCZ7lCZ8dvQV52zEq9KwnudsYymxY2Aqzudkq076WutwzLv6Zhd17FcHDLviN7QpZ4Ul9BZF3KfjMpZFD9FrNjs8g4goqh0pLgx6mozmawuD2/BLU9qq/elmfI20Wuz0wc0KV2XM36x4NY2hanmzo+tYnr5vetMJsM74SQ5Dj6gaL23vT0Mdq5rANBywT0wZZ/bdEpTLDAROJN82HUwKw638tCqJqVMbKCiM1RNw5Fb6Kc46qrls8VZP0shLbRRqxksFot67Bito/mDWDStlfUXB1wdXr6+3//jvwcXlaSjXW8ujCuh3huHPV5ok84rvrNjliz5zsloncthQJJyejcYFu8SlDm/zGswTg2GcW4emGZ8f0kgoblXILgd9/1sgI3RHH2KpdFsSyKirEW9dSMzFdtjjCQnRHH0qkR/7j/+e9vbt9XONwQ0bvQsd35e4Kw/53/mUgtom7laU1XOTAbTOUd/9txqbcFxa7bwDimI7Qan9rGCoc96BMJo2jTuLKuo/s4EtcyCRb6ekIexlBkHVYaaDvJ0saLtk1Jk5qN14scbhBVMXWFhGb/kHYp2rjKTuq5rAtkU9FJKswBs9NP5/bGT5cfciOgCxXZDBQpy/sHwmEFAtgto70GZ6jYFaoOEiqJscorrO+KpcHL/JR57dD8Scm8fWfvQz/a5ToHm//Q2BvKD2vfbQuR2Fqk6yTy75K0RLAvJtTbfYbQUQtd8ceY12+vYZphsUyS3mTrdYjkTLmuhkRoM8vpLZl/WosmhyeGrDLZZylLXdgx7XhG+WyznncuVKZN3BKlz0HsYI4yR9empFd6TMZNKg9muOghQpSEieTcWp36IWvyVxO07t0A9IQ71njmfqaAN7r99jy2GNJ+F/F6WHUDts2BR30MLBI4uWj+DyJ4FtLeH2853DYApi50ofy011GSKVSfdexE5wy0v1EOnXWUDtTuBMswkiaVlU/a6Oz5uUzt34fCHh4emuSNlXQWOCFWJsnWeLYxUzlGvZ+u8dScg1kgVK0OqXGe+bjftasao+DxKqxOjZzrXVdooDaWyMHNSVNs7OOHowgU0KoNEeu/onUdyX8Ku0ZqS1CSmRYxV1RSD293Q1atXJygLTwwWgKwesh1YS81iYv6012q7nUkyutYRUk8qbC4BcULSAefOMrL2treHyc55AHDAPEuzgqwYUVPMY0tudqqy0VtaQCJSRySSfxYm3Lo6/lxIbF/XQi4tjNEWhktG32brp6en+e/zIOJcx1mdmrPY93QenT23ylDI9LdFZ/TTiovnSWYxZHE8l+hQZByQRUdMIVdLFdSw8RLDyjU4VyAYh+TgpMuOPpkjT4B3/oE7LhCkA41z59/CROX36doCvvOUQNZet70HRvtszeAlILns3c9Se9vjtO+T6/dy0Ht7uO1cQ0AP6tTUXMj0iHX0NrLCmh1UOxHMqJ3Mfm6zVo/QZUe9uwCZzgiRlaK0/Tx3apUiuWNnsF0wbjP9doSkOakxyypneGNrMlk55zgYJdRYRUqKYhRRHa17dzQGT/IGTW02GyPRjM0YzeaYi+ZjUbqPo3i0UW4QDKvfLly3gdKnvEMoGkm1OSvDMbl/oHyV+6VJ5sPl6zmnzL9QSe2chTEVz1yLBepkfQB5ulwQZTxZ43UHg2pve3uI7FwHgN14v9UCqtxATHX6VMG3C93TZCIa1k+RiJC5s4AsUyBw9/j+B56zrKsNDqq7O35tfu9ciuBBVmQS2kACDucjw3h6phcgRtPcT1Eq1fP+/fucnJwQY7RC7aAwrNlEtUHoIeFi6VHwjDrf4YiIDW3JOwqA5DqGXYNYvNaazHZhuspYaJoFWiUQ03Bmx3Tmbnt2N4U1Dr9APVXf6QPIDLVHIdcsujGR0tqUQfe2t4fYzjUEFMlQTSunLGJ5fWmIMlILkLNSBbLQW3U+FesXg2wy/7w4hpC56l6Fi4dHO9eiqvR9zzCsK0yUEhUHjztCqTmceoQGykhns9sduwJwjOO01hYq0iQkjVWtM6XE4RLW90859R7vHUmDdfHqfdbrNdevXDUH2HWkFHCihNHjY0S6gNNDhjhUR+m9J0VqI5jVHfKYTNfbrkjzjsszg3qAqfibi7KiHX3nLDBkBdRy3O1aR613PKDo72oBNxeiS3CIgqpDGShdy/n2233vHeNG6JcdsB8JubeH2851AHDJhpW32aKmXKTcdgwxIW5C/rWhU5aagGnHqwlGqlYGUCdT9vpB83/X6/UMCnJZuzjnyuVR4CwrpqyldWq7dg3brzVnPWHZMUY0COthQxrM+Z+c3CPEgXc2gYPVEVEDm82Gvl/S5wlh6oQ7J/c5ODggaWQp3mohvSmpKj0qIWfW5vxbWYvSVJaaNdtOy6Jg2t4lbF2WqoITgpoERxSbofCge93el9L1205aS7lOoJTur/w6DSRN+YFJRnwiDgib4T5eEul8f/z3trdvu53r/4CYNrPCq+Hklt2rmrSx09y5y9yhStIaBKRODdlyNrXrldk5HuSUisPfbfZ4CDb68UHH+FYfL06/1AKEJYHAYh14594tHMJmCNy5cwdNibt37/Iv/fE/ynJxkRWJgwtHvPbiy/y7/96/w+/7fT/BV197mSeffBIJieVyySL3MrQ6/+2520BVuoYBNPmM3XsgGnMnDTVQOcVUSJvZCNtS2CEJzvkHBsCz62FaxwPMJQ8youx+/6LYLrJTcCl3X7Onge7t4bZz3Qh2f32q4t0sA56Kpk0dIFvJdCs1ULIeTZ38VFgyuYGowAia4RJcHbU4uy/qQELNiH3h06tDO5gyTZeLsOA75cNKLCJSg1JhMG0XlGGqD6zv32O9XjOsR955+Wv8+Z/5Wfzphnv3joki3BpHJI1ARxKHRqN49p1jtTpksVzy1//W3+DilatcuXYDnFRqZeeNHWUSFjI5Z9flQJvF1cQK5t77SqetkA2epGHmqIvcdvnZbqc9EGM0eYbtIKCCuOm9dk6aIK2zY0FpkktVzrq8h/nuAQ7RDDk5z+23X+bgaEHggBuXr+8bwfb2UbXv7EYw5exErykQRGKcaCk2Gews42dyQNPMWkdi3g0sppOj80y1dKomDTkrzsVOL1baFXMuJWPWaHi970oW2g4cOVsMVlVUGvpqfqweT5U4BhzC5//JL1kQODnlD/3ET/CH/sCfYH3rfe7cep9NjNw6HWvQOHCOpUJHZr2ExDiO3H7/ff7YH/4XCeOG+yenpFSyf8cYA9FRm7TKnF9HgjTdZ49U9k69V5plMmSw8ZzlPZk57fy+NOMjZ7WF2X1pd3O7ZbjtqNGGv4uQ8vGt36x5H5NCnmnQOUcKEc+GFB1uPxFsbw+5nesAsDm9f4Z//yDIIKVURwgWK7MCCjuoPjf3DVRROAUNEVxX/w6T4zebdwK7zpRE69+T2D4gZ+uGWZd1F+f/4Nu9K9A5BC9KCgO/6Tf8Ru6fnPDH/+AfJt6+T79ccTJGBhHurk841cBJjJzguT9E7mvkHo7bSTlm4N5mg4iyGDwn77xPp6ecHB+zGU5RhipEV7qYi45/WUvSgOaGLlurw2muzRDN89Zh7DopqSq41ONSX9+nD7v2qgBa4TmpxxRvgH8EUF+ZXpLZQF4muqyIEDshebH6A8owrDlY9Hi/wKdzjYDubW/fdjvXAeCN119qYICpuNratkORNDmf+liViMi1APWM2bGkaIVJdZKlExziOqLOefkwsVOGocgWTGuKmmwWb3POaX2OlFzN7guNM6WEaELj9JiqwRgac0BLwjjAnTt3iOv73H33FrdCJISB9zeBoELwfVXB9AoLJ1wHLkvEp4BLHTFGhhhgPOUn/9gf4d6pdSk7hxWK8bitoqxTcNLZlzPYp2D6ISU242ic/ZytO5WcvVNlIKKD5DckvwG09g60TKizvRflq4XECtW0ee8Fg+9wTPMOBiZILpm8dcPaSptjklvYGf7/An/2trdzYuc6ABwcLkk6zJqlHmStE5mUOrf+Jqlm9V48xJglJOzL5eKylAH0af7dzp/oOrfDaW2bOSBRkGDwUWlKagusKU2NXy3d0zlXh7cMw6lh/0PHyfg+qgHpFyw74bRPiDpcssy8U0/XYyMiZUEv1gXsojKIZ7VacSFubLauM1G6FJT1aOMe1+u1sYC60lUrxDhdf92RSarPOT09RZ1UqeltyqpLbhrvKNPs4Bik2TV8sInk2k2NAFOQ2BaAa9+XQjX1DkQdw/o+6veZ/972Buc8AFy9dIOTu7dQ3TGSsLGZ85cdgUJN26Z0D3tAcuNXgYiUSJRAwZwLr32ydqfhaj3ggdh+dUaJJPOiZJGRAMtCN+Mwc5gqWEHTW8F0tVpx/fp1Di4s+DP/9p9DnWckcOFwxWG/5FK/4oKPXD/suSyR0zgQ8KydgHiu+wU3jjoudZ6rGvnBH/9R+uWi9gScrgNHq0MAFv3KsvRo921MAekx7SDpkK7QZCcHfHBwQAxTc1fR+4e8O4oJl2ctlI5nCyJF1G6q1/jK6XwA/1+ZJK0VokTUzyW6y/FKkd1hncUxjqyWPUifh/7sG8H29nDbuQ4Arl9x9723cGmsDtKrfe0yVc0OhImSWLJXZ+MQoyHWhiFLAjGoxWmmEpZhMo08cl5N/d2+bDdgzJ+WDRPr48Y+0XqT7Vjd7PlA5tyPqEa8GixULBFBEvfu36HvPb/pB34DOOUv/Nyf5vt//cf4cz/3M6gf+NHf++OIKI9+/Ek2xydcefI6//xv+QFc3/HS7be58cQzvPnu23RXV/zkn/lTeUbvAuc6ut4xhjWKdVH7rjhgj8fhkqdfeMTpNIcggdMi4wDiEiHXijWvGYlo8pnFUyCcVGUkttVYC2w0v+/FbE1Jpi+LQ75ORttlIoJ4R0KI62O0sx4Cpx9MSQrS/AAAIABJREFUK93b3h4GO9d7YRHh0pXrbMKGxWKBKkTN/P6trf6Z2oC1ENvPGiCe7VSd2CRZRTM/7oiVTZQkS5Ops6YjUpZAcDUTLuderVZVBM7nbteBDEPkZrRJRE5yBt7z4osv8vjjj9va3FQ4FoVOPZssn7BYrHjq2c/yTz73j3jllZf45Pf+ICcnJzz18ef43//Xf8jv+l0/RkqJX3n+K/zUT/8rLA8u8Yuf/zwff/Qmf/bn/k1Wl69x6ZGbLJYXWS2XBunEzMbJzrzGHokgipSZy7lIrFnbR0rAq7dd8F2G0NrOZVlbw5WAq8cJ9R4kNQXP7f6L6f3USrnd3hWkHHis8GDHCMGOXW5jGSWZknJ8+1UuXHuEqPvsf297g3O+Awjq6Jc99++8iwbFFVpmy5GXhDq1zNE3ipzprOgbwbJ8Y40EzphEUBt2otLhEXpXpAZK0dKhGhmGoayAAuucnh7TQkKlcFrMApU1UbmkuKSkYeTpx5+wnY1M11ecbDnO5cuX8a7HdwvGKNx49GmuXX8U3zuG19/iiu/43b/v9/Bv/OzP8Wd/9s+zvP4kX33hBf7qf/XXWazv8ad/6l/DXVwhvkcWHWNc03XemrYEQtyYRIabGFPm8DtUOjZhY6TLONj92wnFTddpsJtl+MqA6qR1VKA8J12lkNoL3awmYAEh7xS2nH/ZtVUKaoaAzPGfheQ2aY27cIQ6nz9HidzEsbe9PbR2rhvBbt2/qylE3nztKzz13PebUFlKswBQCqU+OaSM+PPz8Y2tuQwbiHiiDBmzNkfgGCFJFQlTZ3IJtZM1lcJoq09UOOdzLR/VCN6xTJ6kyqDW09AliN6KtWOKqIDD+PaJiZninIMQQTuCRNanA5eOPOtTE34LweQe7t+/z+/+HT/M//T3/g6XLlzmf/77f48//kd/ktdfeZXu4iViOuXkdEM/Bi4/+RSu61kuPcvlAcIK6ZPBZmoMn4hm5o9JcHi3ygXs+ZCaYpVSm02UM7pIQpajKIFjq/DbTibbPsdZemyqYn8KUArMelrfl/K6EoBFhLvvvcFi6XB+CbpEnaIhcu3KvhFsbx9Z+9DP9rkOAO8e31UXlfH0NsvlZbrDBSKeEEJ1SNN4wY7kUtXyqTIGTSeqJw9eyQ4/uVgDgImVhVkjmU+TQ56kGWJl6ey2XPyMeYeRM9TktQ5nhwl/HseY6ZVUimmhW5bjuZivVQfC6IkuVhqpc47Te3dNFnpjAW2zvkd/eIVeHH/wx3+Uv/KX/2M+8UO/mc06Qu9ZLBb0fZ+hH5+z8dxJW6Q0vA1LKQ40hVO8dCRXgmXpovZnejVqH0UsjWVdhb5Kgb3era37WN7TVhxv1vXbqqIK0yznWNY/1YpEBDpb/+svf41rVx9BXA+6wHl7P69curoPAHv7qNqHfrbP/R7Yi5AWS95650WeeOYziJjTqOMDC64vwTLZmHAicwpodiYRoz4mopUUy2CY0m0qVrC1weZnO3TNmUNhwJg0hK8aQQZDWKbv/LzL1UTsuixsNu1iesGKvpmi2QaJYtFhGLdfIJLopbdzxMx+WRwAZA2iSL+wkY2dP+JTP/gDfOKHfguRSHewNIxcHSkoX//GF/nYJ78P33eWSTupXsmPkW7RE7L8RedWtdlKVUnZiycxcT1RnQq42P1DQLYgmVJnEJFKCS2QkEfQ1NRz1KEkohOj0yZFvZDUOpyJmcmlihPya/N58vkjCmHk4PAQh0cxWQ9Vj8a9D97bw23newdw97YWh/nO68/z2FPfTdcvgbOsj3YGrxUtrfNUdRoBWbLJti6wS5p526rTawTaauDRzInPy7m/OeXg4ICzRca2Kxgkd6ymFLZ2LWd3Fi47qgKt+ERtGnPOMWR2TimA6mDf7967zYVLV7g/rFn2Kxa+J4TAarWqUIrvVzO4pWbbeSyjbOUIKXc/d/mJQlcdf7HKxnLdvLehHdzT/P6tsHGcE8jjNKsGVNKmG/ss7u+9J0rP26/8KtevXyV5oUsdNsXNdhrXr17b7wD29lG1D/1sn+sisJkNY7l542nG0+OZymRb/JuceIEcJvxfkjmkIhVRuoVnuHZ7Rp3j2qh1D7QaOOQpYc5nrruzSVNF36adGLbLVCPvv/8eXbegUEZLTUF0Cihg2kPRGbPIayKIop1DO0fyVqgWERaLBV3X0S88vhOuXLmCI3HvnTdYOoN8VivTwI8Arp+KqRi+XgrnCc/dk/VMybPcO8809N74+1plIezaZS7HnR+rRV5JOP/hzX3N3Zodpwzvic1uqh2oA9CLwyvoMCIEk7PWAwoNN6rNN97b3h5mO/c7gPJzihveeOVrPP2J72HRXUIZZ7uA9p9/YuvkoSaV5rn7H77WE0oBNuXUdIeDKEPd7VwtndBVWAYguqk4LCIsZD5noGTzxbH6lBlNUgrJrWOczlGay+rjumzWmQijpyOvscvDWqSvgfLOndtcvXZ5UvlkYvw45+rAeXXmaEtAKyalsco190YdsjUcvgyW37apmc+gmA/P/q1Du+w8nHMV92+1i1rmVdsweOvtN1gshW51hLCa7l2wHdSN64/sdwB7+6jad34NgPzP773niSeeIJzeo794MH/GDA5yqObqbS4Ibjv+bXnitmBsD2w5RSXr/Ag4h+imKVZOjv34+Jijo6OtBi/7OYjmt8PWutmM9H0/TcVyiuDyBLSAc9IEgvlQ9WlourcuZk2gPQh0veKTZz0OLBerDFVFBEff91y/edOu1TnTTKrF3unaNSWjy4qrSqBO8gB1lwzjTx6V3M1L3gnkz5uWtRdnW6iekjBef2mi+2Cz98MmfAmKqCIoqTbdae0paGUfyvWN48jxyV0uXHyUpH2l8sYYwXnW6/WHrmFve/so27mGgIw5YqqTnSzw/SVef/31WXZ8tgM0FxadIp2vzr6FGlqIZ7aLiJM4XJvNRoc5WrEOV+emuDll9YGD1YV5ll8z0wmiKLZcLmcOq2X+2PEdMepsZ/Ngc6RmYnt0sDxY1fU55/Kc3UQnBhl5siTD1r0wQTw/9VBkLn/QZPcl36PobMcy5+hrHbdpv5ZdgHVLo92kCZT/ngqZaGcTmMFSmnc0gvUNbM8ebn8u2X9K8MabL3Pl6oEFR6bdFkDcrImbkw+5r3vb20fbzvcOQBIpT64aNSCu55Ebl9FxgN4KjK0sREIaKmM6A6Vs0xUh4GRJSsZ5p9OZhMQ2PFHPJVKpja1UxDAec9itrF+49CSQZh3IKU1Y/3yHNu+4haabNZ+i1AVa+OhBGPqMRtkqqWrrrKf1J2w5LvWoRmsIs7POsvtpdzQVb5OoBVzn8GkxAVT1OQUOK+sqW6/pHrfXUqAd02lyEG2HhEuEGKEpxFd57q1UJsYRn0b84lru9M7HTEKMyhDg2Wdu7Lx3e9vbw2LnegcQ02CzfpPh7RHh4OAyf+Pn/0MkJlxS1DsCSpSp7R8y9p6kKXBOWjSTdSBxctAxVZZQwZzhbFG4ZOXzOQXWXEV1YoGiCWSHmZxVkYgumkD1GGpO3ovLTUw9Ir7uDrRz0Lc7BfveCyxz81sRWitDXUrh2rpufb2vKSU0OTRZx24pjKeUeyHwRHVndkP1NbN7KSR1hHFrGM82BdRpbaRr72Uxp7bb85JmtQkb9AMSXZ3uVgYCFe2l2mHsIqrCa2+9zZXL16ym4ULzPkAKIyvdcF8usre9Pcx2rovAb91+UzV1c/aNRtZ3Xmd5cInF0VW89iRdo6m37k6ZtvolQ2wd9a7u4G3bzqxVFe96UlKcE5JLlRFTjjcNUJ8kI3aZzxz45KedA0yS0NtrfVCGX/sLtq5lHMczhdv2NVGlXoc0qqR1yPp2B26cePq1qJ6dcnmO9w7RSMLhfXdGzqFeU5HTKEXr1IMb68D5GtiIFX6qu4EUbThOZfvMZxlXeQnXMQwDb73+TR69+VjtVyib3XEcOT095fEb17h3esijV78lGtK3w87vP97ePir2nU0Dla6rHa/VMeG5cPFRXn/zVUIIplDpFnUMY3nerDM1D1sBqpMuWWNrBulM9Mb2eEkDSMzCcgmfsfE26y5DYlTFMvlZsmvnDKIE0WZXMD/3tHMgd7Xa6w4PDjg6OJhTLbdw89JEtivA1T4IjMNfnb/6mtFbM5xNAqsTvRpphrbz2iNVUVPEkbLcQ6F5VqVVl6GmIrCXdx5VBTTNnb/dKU+KgsSx6jaJTp+D9vq8YrpK+fUxKO++/ipXrxwSZ1xeCxpeEwunsDrkzvsvnLlPe9vbw2TnOgBsNoeICznjNClnFQh+weOPP86dd18nxYbFQ3YItM4xNaJs5gQm5znX5j8L00y27VRtROIkS1AyY682gCW6RHSpcvdLP0NhoRjUEmugcEmrM9NKc7QvjXB675h7x8fViW47w5QSC/FVNqKus+HxbzeyWdCZZ/gamwJ3sCli6gyP13beb2+zAewcZffzwQlHS8+0B9IECcVkjKMYK+wXxZNws2tsxfYAAkpyZSfSM44jiVNkcZSLv9N7GmNkGNbcePwab762+RZ7EPa2t4+unesA4N2aq9eeZJAN2137vb+KsCamO4zJ2fxfOAOhFO58jDGzamByCnMtfxd13oC1xTbZDgLbDuTw8JDkfIUdVK02ERtcHCxY9HS4aGyVJObIRk21ltHuBFTOCqy1nc+V2eLI3P9Q+xXa6wDysBZPDHZvLEMPTXDIAUoAn4fDq2ZGT2lyyw14EYSeVtN/G+Nv19gGrO1MvjSfpXpPFUfMU9rmBeJtc85BUkIYePvNF7h67WZe05x5lVKCtGHjLjCsX6KX882B2Nvevt12rgOApJE333yLuGE22xUguMTFS4/x+msvk1LW4O9Mb9+VsYsKLp2FVWwXYDuAdlRj6kbLOhulzzqnt5E0OBMI8q+bzcYy61o1bW/vPHu1WblCdIGYRegcxmrSmLYydrsGlyIuzbHvlJKNnAxtJ6zjQW9t0iL5PAWHArPZgQ1W0zA9JikXbyXMdgtW1A11iPu2tcXzlnI67z6epnvZDIJoO6saSOZSHeUetYOBVJXUO4b1hgsHHXRnC+WWAERuPv0077x+m1EdGzfvD9nb3h42O9cBAODgIHD58qOIC5atM04Z4eICFy4dcefdNw06UQVPhg0iKpZRV/mAlDANGNiGegpPvfDpy3PLa6ciL/n5TTabH/YL67iVXnLhWpvnl8LwRA9VjYg6+xLBdZ5RE7ipsDnBHxCShQ9bSxkqb8EkurYwHGfBqv2qzrsEkJzpl2Ytn2mfZBpr1IS6iUpaoSCd6gYlSKrqrEt3NnwnCSKemINq0IiG+eAdlzwSJ4etqSOMUp23sZOM+VXO3SF4ccQx8Ppr32S5uoBokeEoOzx7zz0b7p0s8Zv36cSxOdn82j+Qe9vbR8jOdQBQVVLwnJze4fq1x4iyRlOBV8wxXzi8yd07rzEO90ipJ0TLVmXrOMaxnwrApYO0/F21ZLxzKeLWdsEPs91ATFWqGiYaZ+H456PMXy9w++4dGwIfglFBvc/4/7QTEBGDgmrTlsNrqhBJqWnsvpHbsNhUE+ilp1OPkxFxgRgHJCUk90N0zhmFdNd90HmWfQZT9408hOQiLLnfIg/kcaqkcYQ6Y3gq4quGwqqtu7Sy9raekFDee+N9Ll9a4hbL2XqDJoYYGMIdHnnsOY6Pb7He0Xy2t709jHauA8DSdzhJdDLwzq1Tg3NCJLlppKD6jpuPfZKXv/E1kgaWRYYZTBZatmiNSetXZbT4Sc5BdvqECb5p4aRibWG1yBoXO1toPHvLL126ZFm9gkpqpo2Vc7umqzbN/hK3i9Mp1OfPCsVZrG0Gp5SgU/sEOpynSm+4bnFGDXS6sGSzf7eOWzV7PsC3Cp7OL3DeAoHzQAq5sN401+VznGVr6VTv6YQwRDbr11kcXiLgiHXaW6n/jFy7cpE33g3EcEq3OCCEMOvE3tveHkY71wFAROikh+To5DYXrjzJ4YUDGCaHnVToDi5z/fpN7r//EqNCct6031XrYJCUEinEWQZMZt5UiqiWzDg0MMouQbgHr7nL1NXW2uasuZXMWZv5A11DVa1nNKydhIsNw8llPR6M3z7pBoVp+hYgGVNv6xjTTW5YNdFGQPb9wqAewozC2b6u7qqaAvm2oy7YvqmF6uzxAvG3ncDla1vZs30PSrc0ToiS2ISRF57/HFcfeQJYAQ7NYzxTCqRBIW3w3U3S6duMY2SMJ6gqm80eAtrbw23nOgDEaF26nTgkdty/8yb96pAxnJ7RyLlw5VGG9R3S7duVyeOKc88KloV2OHNU2TEXiMWccMHqJ8jh12KtVPWuv+Wf8veGoaPz36dzZy0daDpt50Gmbf5qG9JEBPHdbH5AOZdkHn+M0QTcOk/vHORB7Kpzx75Le0c1GrOogW+KpRSBdjZz+5xm1OYD6hQak+3WmnsxrcUDHW+//A5Xb15k4ZdI19ZoDPePaeDSIzd45dVXOA13TMp6mDqI97a3h9nOdQAoA06cc4hLSEy8994tVocLy5qlLcQmrl1/im++8QuMJ3dxjTxwGyxm4wUFQoaVaCZRFdjorMR0sQ93HOM4zl63Db1MX2VAiRU4665AsTU1+P1IgVZMhTQ9gMRSgoZD8q4m7ggQ0/eu62pjV8yCd1a03SG25iYt/3y2ms6f2QXkYm3RVrLMXif4iHmfwvReWdHXupCnoNV1ixrUYlB+9fmvcfu9X2V1+JjNVVZoqb0xRhJ3cOkQ0UAvPSEMlOC4rwHs7WG3cx0AYoxshhOSjlP3aDqlk2usx8AmGJ0zOIjqEXfAY4//EF99/hfYbDY2Ozf7MMtrHQE5Q5K05jHYhLF51AJO0RwqmWgNODFU6iVMrJfytc1b/yBnUxhAznVTZi2Ay7uSnK0uMvWyTBNTRiA19NCUA2N2kgkS44z5U0cwegeZ3aMCySWSswDjEUSmAu+M/ZScKYZOq88wj+BxWcPHsn6H7bgKzu881k09g3fyPAQ/yT5UFVVJaIwQYqZ9JrxYQ939u/fR8B5Pfep78N2SsRH+KzBSjJGnnvgsb7/1BpFIvzogaCqgFt1y8WEfwb3t7SNt5zoAdL3gpDed/L4joCyk4+Teu9y8+Thxc0yMWZNHElEci9WSp5/7Lt568VdwQ7RCsAf1Ds9Ih/UKiCjISEQZMLpoX7Fjc+Ku60hOcpOZzqicKq42Z+1iBwGVOjpreGIaUDO3aZBJ2RVMj/l8Tk9oupzL4wlHcr6uT8SbE5WESF/prK0y6BlrpC1g7vh3dcy2RV91kFy0OrV0FhCY02ZbWmiL9bd/3+7Mnt23NPVknJzc5+UXf4nLjzxW72W5tnLczRgZTt7i7gY0Dix8x+n94ywQ6OquZG97e5jtXAeAGCPDeMp6c4onsvBYkdcr7771FodXrhtMkqKpVqoS1eH0EJXIW++8zDhM2WPpDnWuM164Qp8sw5fGGVSn7bYdpjGAZlBHk31vQ0Ml41ZVQhISPne3xoqLz+iMFSs/63RLjYIG2qrPcXPnbj9PWkLfCtvFEfFF3199ZQ6ZNtCcCdQWbvPqbIBMdvwFEmobzFR1piSab15VH7UvC3ZFziM5sSlpGm0GTue5txn55S/+Q65eusLRYkWXdypFriKlRAgDaQw89cnv463X37K15F3JNp10b3t7mO1c98IbbBEJo+f0ZODw8BCvG1KKJCec3ruNJkEH4eDgwLBjge7iERflKd5+8wVO3rvNM9/1G2d68TE3PyXtUVHrg1ILAoIpOjtxhkEDo2Y9IW0LxVYkFSeN/n2aZaKtOSKkWOmLtRMWw6q992eok7X5qpVMzvOOi21n2fOhMpx5/fbzHmTmyCMxOWDESb4mGUnqcAl8Hfs4gjibFLalB9RCPSJlR1TW7mnjnE1CcxW28xnTR6x0vDmJnL77DY6koztcEZPH5x1PCkqMG9aj1Y0ODxO33km4dJckQgomrCTRehxSHG39e9vbQ2zn+j/AqJoe7xRxiWE8RhcdmrXvBQ++wznH6emxYc06kCIsVhd45OazjIu7HL//nlFAy6B2sUy+CLXFrMUTiAwSqyZP+Vo4b30DTghpRGQXg0Wq051RTRtr6wItJNL2IeyytmgsIvMGq63nfdAxinVdh5MOJ/1s1zDvdI7z6V15VoJLfZ2ZnFLKDV3zY0zZ9pzB02L/85pJmPVX9OLopS2UQwrCm9/4MotLl/mu7/0h7J20mk0IAR8joQYW4cqN51gf357mIqgdt/y9cz07GL5729tDZec6AMQYETpigHEzEIaRNAYWiwVOA5JGnCZitELnEBKRPjvWBf3yKjdvfJbXXv0VXn/jJTRuIHPpXWq7SQ2+KZRTmGfNAWPoFLnnVl66te1Gq/KY2bbyaH40YtLHjdTy/HXNc4tkgkKXJZhTHne4y1o8H3JzVzMYpujye+9tcEpyjDqQnF0neTCLl1Qhlu21tMGo0jjTpCU0TTdzs8loAF2yr8mmj6OIQUDBC6c68Mo3v8LVJ69DdAzjhitXn8L7A2IcGYY198KGzckpaTS57ldffolB77FcLisjy1hlViiP0epGe9vbw2znOgCkFBjiGtebQNo6ejYhsl6vWfQHoJ6kYRqjGBNpDDbVK6XMbT/i5pOf4a1Xvspbr79F0LF2+waEKB24kYXMaYkAHTlQFM587ieQPC7SslrQ5BGd1wAmwTmzUrA9Y5J2MmO+Fanizimdt3Xvyv7L8az+UCCclEXXJudcsPqUEp24OhUtuoSKz4yeWGEhJDZNXsz0f0qhdrruecYPIDHQC6TORP2KeQWJqd5FlxTZJF74yhe4du0K/WJVG+2G8Zh+uWK56rl37x7j+hQkcOPxKzzxzLNceeQZYoycnp4SY8yNckoYRuIYDI7alwD29pDbua4BeN8TAwwhAoJPERcU13WMCv1hTzwdUbK+vYEPJBUWvbX70wvSHfLUc5/llV/9PEerf46LV68Z0J8zf9EFQRQdA533JGcOa5O19SVYQxp9Z0VnoDQ0mYMLecLvNkPHTrNLymCXgy8Zciu8Nvt7qTs/KDbkzL4WkjXLPBQn3ao251pFzdC9RTmXmVAuKYInEkGpGkzi5llz21y2/bhd0wRv2VyEDK1pqnWF0q0dxe5BR94RRceLL/5jbt68DKsbRNmAk9q9nSTgU8/HPvYx3PISL33za9y+O7J57006zQ4/79Rcqc2M3oTgxvHMmve2t4fNzvVIyG+8+DXV5FgsFqzXa/re4J2u65C+MyzbOdbrNeKUlCJODBLp+x5No0kVqBDiKSebNS9/6XN8/Nf9Vg4vX2dp1V5UlfV6TbdaAq3UQxlH2GDkSRFVNHPpS09UUR2tpl2VX6gPNV2u26qcu6wNBDFGejdn85wp5uYRinXk4tZ5zwSYD9K0YCtw6e4AsNtMFK80nz3oM7Y9Z6HUOJKAhshLX3+e69cPWB1dpPOHdh24PNfBdkzRRYb1gl4iSdfcvn+cZyHbZ0ViqMX5EAIOb7OE87X/xh/4wQ/fan177Pz+4+3to2If+tk+1xCQJkfSkWE8xrkJqhjH0SY/ZVhhtVrRqcfnoqYTJY1r+gwNxRTo+wMOV9d5+tPfywvf+Bybk/dN6jjj1svlEqcBT8tDL7x62y2kFJBMRxQxeGjbUsqvk7AT838Qg6cVnJsJvuVrLFTObQmMWTFVxzPOH8hSDYVlM4djdtnOLtkM/ZRr+ECl1KRVlG/byu6i6Pn34mox3iWTd9agfOOF57lyZcFqdR3SATGQg5Cr9yPGkd5fwsVjfGfNZNcvX+H03n3iZo1EgwcdguYitmDMLtWIk30j2N4ebjvfAUDV1ChzobOMcxQRdAxINOVMVUX6nG2OwQaOOFcHpNeB68BidZGbz/w6vvnlz/H+e7cI2mDvudvYOXA+zeSjVW227WYwTBmXeeq5UayutwyYkYDQM80ZnnfpnjW39TU51VZKoZznw7L3mdVi54MHxex82S6YKtlc3XJNrVTG1GXcEcVNdYU8xMVFoasNYhPTqp6nEwLK6698nUcvHXB44QaIt52Ed4wKJ8OGTQycnJwQQuL+nXdIaC7wGoX0yiPXiWkgpjWb03WtTYhzjFmuW4NkUsDe9vbw2rkOAIGppT9Go1pOv0eOj4/RMaHjVJR1XnFeZs6y6zpzTi5wcHDE4cFFbnzi+/jKl/4RL73yVU7HgVDqCLlQKhgc5JyrtESfHF7mg+q3B8VAzqCTr8NryjqKFaXKb0VTaCelNDdr/VqtDRwfBD21Gf729xLwNLUzC2LW7JkKwW2AGpL1ZySvROly4PRTDaLrUfFsNiPPf+lzXDjqWRxcMUhLrPkvpimAem8d0UNSko50vdB1HZvNBomJXuDC0VWcg2FzwmZzhxiCfUV7b/zCE/YozN4ecjvXAaBDoPMMaXK4Nr82VBx7GNacnNxHVeh7P3Ns1hUaGIbBgoCzDPOg77l4cMhnvvsHOL5zi5e++UXCejQn5cQcvYbKAoJSNO3oXV/hmEJtbFUsK2STIY4JTikiZcVZdpy9/bu7idvv9kvcCfV8mLWYe0tP3YacWpt2R+X8eReRVVVt8lmWqmgCW5HTniC0FvKZxjk655AAJyHwK7/8f3L9+gHOHwAr2x3kukCMynptcxI2mw0XD1Z0WE1gsw7cv3eLMJ6wPr3LZn0MJBb9RS5cOmI8GRiGU8ZxjZNI7PLaznH9a297+//CznUAiDGShtHm5BZ53wBgg0xaIbbbt2+jmFDZsInEQOW2RzxjElx0+ORJ0hHxLA86nnzyU5yEY37xF/8Xbt++zTiOFZpQNRmE8ntySiRWcbhp+tfk6L33Z7T/59n2pFY5txamOWvfarF+/ryzAWXXetpz+mRfU5DIO5Vc05Bos4lFNENk8yav9n50sjZsvxR3cwBW7+pYxxgjt4/v8I2v/EM++clPsbz0DIv+gKQDkoduPbsQAAASQElEQVTahDBQ5hGfnN7j+qNP8e69OxU+inof8R0qkwz3OJyCBrzvufbYYyQdWK83da3DMLCZDd7Z294ePjvXLKCvfu0rhayRHbIaf1zAq7E8fKcV5gFYLBZTX0CxLEGQnKPvlhTFyfIV0inv37nH6y9+kWc//kNcv341S0soXWYADRprNlqcXen8LVIOMGf6mHxEdlIuoHEFMqcfTs74/2EsVtdg/HP7YMnj9jWuKVjbz10mEIyadgSMiRUl0SiwKuXarSeiXo06tCsdvt2sMWxIkX/yuS9w9coJj918FucO6XqPup4QAkGtSW29XhvzKymPP/0xXvjG1+nTgCUCCWSDkx5lQGOG8dSou76zGpISuHXrFuNmYLFYEKJdw4/8yG/bs4D29lG1D/1sn+s+gFHBeRtYEgVSjLguD17XgPhACFKHmoBJOncxcnBwwHq9ZrlcEqMQQ8QtfC0Ml4Yl7z2+O+SRqz2H/vt5/eVf4a1XVnz2u76P5aVLhDKLQI3nLxg0lZwQ4oj3/Qxb99lhJpeDUBmwkvoK2xTHXDjw5kBNuK2Fab6l4NBO9MrP2zXu0ALB/PjTcaesPeSeh5i7pJzMz53S1sAWR9biV8aYbCiLGEPLOxv7GCVDc9mhB5T1OPL1L3+Rj31yRdc/Q5BDlm7kNHUsvGPIzWVjioh3xJMTnvnUp3nx69/ExzWD98gwogx4JyTd2C5RDR4U7VFZMwwJGPC+58qVK5CUN958icPFAWHPAtrbQ27nGgIaYjCWjhNzMs5VPfeAEnTKwGNUNI2k9UAcA8NgkhFtZ6pLRkEchjBT03SyQFhw4cIlnnr213Hz0ev88i/9A+7fuUXYnBjFNAFxQJLtJkw8YcLnvTd8P+S1SdrgdA4xVAZTw8uP4vJYx91DVYrj3v6aVC0TRQK6PL/l37f1iQl+skExEgODT6ZHESJxM9D3pphacPpC2ZzGNBqryaWIz5pINtwl0Xtj+wgL1C2JYvMXUGMOJSCkxLvvvs3/9b/9XY4urThaPcFB3+NZW3NfNw3T2YwD4zAwnNzjmU99gq++8CLEU7tncSBIJCUYRyVFK4x3zmifoGha0HcdqDKOG1MeFXj0sWc4HQeG0z0EtLeH2871DqDruurQCrOkdMOOuSGszxm4poEQE4ve4AM3jHTdkq7rTDqiaSbzCGE94pcdTkomL0i/4rDrOTxccbD0vPLqF1hvLvLZT383hxcvIOpJCt4nmzubx0Z673Ep0UtnkIdGCggi0SFujdKTkk689HyNhqX7qfksmNIpTHh+C5uUx0tTmiNP8aLsKiwQucz9nySkzSnW42bRtm5j5xNV+r4nxIjGROzy65MizpuChBvRDONYDVVxLmuAlgauBCKJTiFp1gYVCJoYSDz/pS/g0j0+/X3fy8HhhTy1q6fvlgR19X0OIRBipEtrbjzz/Xzhi1/mYOk4TdbPIEHx/UBkQe8UkZCvrUBUoJrYDBFxisY8SN47kI5HH/0YJye3/1/8tO5tb995dq5rAP/0+S+racQX6MQjyaiXhdrZZcfns6xAoQp2vf2+XB3SLRekMdSegWlmb2SxWNGtlmw2G5I4/AjqB5zzbI6PuXX7JV5/7V2e/cR3c+PaY6xWzdQuzU4PkxrQJCagpgnIjnKGxEw1AfVnJaMhQyQh1N1CW8uQDKXsajArxz89PeVgubLX5+dFaeYrd10ONmHaCeg0jrFAaSlH2j7z+VV6E93Lxdu+KbiW0ZzOWXG+3l8nlT303vu3eOkbv8zjNy+zOHyM5dIj3ZEFLSc4tyClQAjWcDcMA49dO+Sl9y/g5U3G4T4aehIjKQYE6wRPuqGLnt672iWuGul9RwiByICXQ+J4gqowhsBycaFOX/ue7/mefQ1gbx9V+86uAUDhlScWiy5n+ik7mqFq49uYQEXEMGrnDUbw3YLTk/ss4gHL5QHLpVR4wTmHpt6czuhschiKW3YMg2Xoi8MDrrpPc3R4jdde+wq3332NJ578NI88cpMkwZx9yoVhMDxebTqXZfkR5/rGYSvk6VyaNYWUaJly5rerKp3ziCpBp8axIklhzVbT7IEyy9i5jkRkuexN3gIo778DxHkTgAuxPGI0SBFUhKiKMk0x8816ABKj1RUk4V1PiANdwyCqcFq3QHLDXogDafC89eorRP82zz73aaRf0vkFrhkBqU6a4Gw1jE988pN84Uu/iuMO0nvC4DnZnDCGRO9GVsueGDeMJ8BS6fuVZfo64v2SlKJ1ekdH9AHfd6TRPicxDYzhhJYnsLe9PYx2rncAn//ql3Q+5MRlqQVlmX8Pw4bFYmGPsyZG6LslSGIclK43jB8nrI5WxKAkNZ2ak5OTyvbx3tP1k7RyjPbaGAMkCLrm1tsv8u5bL3H5yid57KlPcfloRWR3Z+8E8fgGh7ch76UreXpdsrqBNNITSetEsgfNFS7iagVucp2fyVRrNHjKixDjWCeQlazci9RmKCk7kxizE53uxTYEVeEeVYiJrivvz4IhjXhNnJ4oX/6VX+Loyh1u3niO5fI60h0xDGv8oq9wlXOOMeSpaXEgnmy4+tjTvPXey3h1DGMkoty9fycHDLW1jZGFd3gx6Mo5Z+8hU8f4MAx0UvpHljmIRoZhoEwi+5Ef/tH9DmBvH1X7zt4BFGdm07IcMZ2Skss/QxLb8o/jSNc7xo3gPGyGE0QcXd/j5P9u79x+5LiOO/ydW3fvzC6X4kWkSCq2ojgxjCSPecldARLk3w6CJLZsy3qJEQOmLVMUJUWkqF3O9HSfS+XhnJ5Z0kaCPBigOPU9LZdcsnuXOHWq6le/8mRJBBu4vNhwdm0Nqb720K8QKQjUdZKpbZNan7VMoYAYrLN0xnLrzgNWp7f54smn/NfH/8r977zHzbffrQNiIbykgV+GjIyAs+7gO2TqJ+uBC1marmhfw671fGsNUqCU3Or4sDSKjdiXuvfL77+6o8C0MpNAXYazrFfE44wgUuq+5Zb9lP33O5Cammmx1ajPdvjYSvUesq4nt3dOJfLixQs+/eQh48VXPPjudzgZ3sOEHuMC1U+pYKWqsayVVrbpmOOO3XjJ2fk9nj77DLIll2qrsbm8xOTMgGXXQZwz1gipRLABSQVvALFkqszTCHhvkRwwwBQv6m6A2dYewv8qkVWU4+C1DgDWWhyOEguRuvQlFPCdZ7e9YBgGpLQbuFj6IVRdf6rNvjokVJpPTL3xji82DKtTnHWUHGvTlkwsmeAGkoxsNpt2q1zUPSDFAyvOr1/nZHWd3XZke/GEjz/6F95/788ZTq+xWq1qSQWurHfMSM5gWp8AgLpasohgLK0U4/ZN1SVjsFRd/TIDsRdtmaqosUvD85VzbLnZm9aozVao5SdpX1P2Q7CtGIRZ1mK2cpNrzqPLE9fb96GhYYzD0VNcJs51KO/xw4fs4mNuv/0O3bs/wNtzAMQUUs61x+JCyzDqu8UYkXzBnTv3+HTXM+4+R0rAUJhjIoZM6T2MhdEB0SAlEUshWzjputqYx4DJuNJRssPazDwnnK0GeF1YEedUy4OpvatVS2jluHmtA4ApmVly21hlKEUoVojbDZ3vybHeqkMIIFLLOwWC64gIfi6MkvC+Hg459TgvTOOItRBOhnoDLbUmn+YtzgXeefCAR49/iXcnVR1kDLFkrBsogAsDp2c9p6sV12/cZ7v5hl///Gf04SZ3vvs9TtcnhOZMupSAnCQQu8/J6g0UEMGYAlIXly8Hs2AppmBb/8AJ5NbrcK9MEtuWGSSToQwYSVBKHVyj2jhka7AUUsn1sGzPkHPE+65ZbBics+ScsG4pW9XMJnjLLKbOK0h1W51T4tmzHZ9+8kNu37zO2Vt3uBH+lG44IReIbcuaFYsx4IowG4EcCe6MbbxgcJmbt77Po0ePELMlRYcxUid1SyJdJLIrBGPorCPFmeIsxlk6PKOFdZxI/SkyTzhXcKWQsofgkCzMUbBmwpiOGKf27oWc/v9+SoryJvFa9wD+46c/Eudc8/Gph72nQ3LBN6M45wK57PDWk0rC2e5gS+A8uLxX55RcJ4Vtq4EnhPV6jS1VIbPUw10ozJue4mdOT69BTshempnxpnrSY1KTfQp5Hvn6+WdcfPM1z55u+N73/4zz82ucrM6AwwzAVW8h+B2e/rBXFtUb++Hz2fz2n3+1lLEMl10d+CrN48gKtYkugLMvFaEXrb8PhpyW2QJTp2vFUEyHSxPbDNtp5pNf/CfPnz7k3rvvc/PGXbrhBONcHdrKpfZhOAzopZTAWfq+x0wQ49fc/cM/5slvtozzk/qczdVzF6vSS0whpglf6rtPccYPPRITMjcxgGnLekxkba5jpE4NJyOEvMPajiyCkUiaM6W0xTBGiHPhg7/THoDyxvJ//t9+rQPADz/6iYDFh3p4gydcWbJiBHKaqzzyiilbQei6gWIKc4wYW/BuTc7T/hAOIQAWYcaGoZZvoDYOqaqa7Dru3XmHi6dfcJEuCX6oh2g7VKumf/HIr/NUed6QY2L74ks+/+IRU3L80Z/8BddWPavVNVKa279dexhCh2HC7nf7phYAflsm+rK53OHjxY562XOMya0xYPdlHSgIhxWQxnkwDmvagzdEBGv6ZupmiZKYpol5Gnn+9Y5PHn7IzesnvH37Pqv1Oa5bM8WE71eHn8tihVEOQWi1WvFsc0nOmVv37/Ps6Ya0ffaSpDfmxG63Y2cSfXHMJOwszID3EGdLMjNWLFLSPhgeymOFVRuC69t8RWTG51rmM8VTeoNLI/NcM5u/+esPNAAobyrf7gDwbz/+kSy33cXXnxQPkkNrSXPc6+X3G6/aEFPiYAW9yBv7vmee51pWaioZvKuZgfVtKKv1DJqdQoznDCcXiBTmZBjCUjmze2XN8jxGqpwxOM92N1LmkXF3wRefPWa73bI+vclbt97n+q1z1i4RujXwysHesp3lEIeCsVQTu3zw6ZGQ69ndmqqDf3lB/FXLiXpQmr1m/5CBACbWvQuwd169vNywGzd8+fhXbDdfsjpf8/Zbdzk5v4fkTOgHHIFiD3+fAWj7knOuQTaEwDiO9YBvjfBYDhbaOWd2ZOI0k5N9ySupxITxhphqdhKnRH9ywjhuoYvYWKWvIkJJEWstK18zwK5v9hOpWkVbJ0zThMtCNHUiXET44G//UQOA8qby7VYBmVy9dJYbbEppv5B9Uf9IKfR9zxRnchaMqQddSjN418pBDu9r87GqT2ppwjaFi8yROVW/ofV6/ZK3kJAZhhdkhMux58b5CXm6PCybCR5jwFugFKLYqskXoe9WlM4RTk45O39Ali3z5XMuLn/Fr3/+nBc7y70773J66x3Ouo4w9K2BvJRfZK8osgIl7Wr5xjsMHTbbOqErhS70xHa4e6pMM0udjbD7X7dyGAXJBUkZEzxxTkzzBXGGn/z7h6xPZ0zZcO/+Xe7cvUXf/QF+NSBJ8CeBnDzOe3KyFBLB2v2A3mJxYa1lmiZijMwlkmtXA6hL53NzCd1IwsQZWxK5+Q7lZXewc6S0Y/COcVuVXilFnC3MxWJzItm+ZnHWkUphu5sIIXCREqfFkV3GTpHoDPNkCDbhrCX9jj0OinJsvNYZwIcffyTVvsEhYvBBkFkOjV+q1j3nTOg7ttstnQ+Ir9ryYADvDjfeNsXqOGQMy2F/VcbZu46u66Dp6q1l//U5Z6xbceOta1x+89/k5Oj7HpF6c5W2Y9h7v5+KXW7e1nrKOFLYEKVOze42E9P2c8bdjp/++GP+8q/+HtetuXX3PqYInTWY4K+UOg5yzGWQ6uqswNXewmJSZ4xhGmeCM0xR2Ixbnn/1hGm7ZTt/Rc6Rs5XjdH2b4ewaIQx04bR+j63FiBCLwftur59f8K7etMsM/VAdWhffnUU1tAxciatb2mLLMrLU9Z4GR0wTY0xt73Od08gFnM9MYyKEmrnt0kTnPWVMFGdqVrGbwQ0URrZkzorDtZ9ZcL5O/bIlR48PbWdDrj+nf/6Hf9IMQHlT+XaXgBRFUZTfH6+1G6iiKIry+0MDgKIoypGiAUBRFOVI0QCgKIpypGgAUBRFOVI0ACiKohwpGgAURVGOFA0AiqIoR4oGAEVRlCNFA4CiKMqRogFAURTlSNEAoCiKcqRoAFAURTlSNAAoiqIcKRoAFEVRjhQNAIqiKEeKBgBFUZQjRQOAoijKkaIBQFEU5UjRAKAoinKkaABQFEU5UjQAKIqiHCkaABRFUY6U/wFqw8zf1WFeuQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x864 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 图像增广方法汇总\n",
    "def image_augment(img, gtboxes, gtlabels, size, means=None):\n",
    "    # 随机改变亮暗、对比度和颜色等\n",
    "    img = random_distort(img)\n",
    "    # 随机填充\n",
    "    img, gtboxes = random_expand(img, gtboxes, fill=means)\n",
    "    # 随机裁剪\n",
    "    img, gtboxes, gtlabels, = random_crop(img, gtboxes, gtlabels)\n",
    "    # 随机缩放\n",
    "    img = random_interp(img, size)\n",
    "    # 随机翻转\n",
    "    img, gtboxes = random_flip(img, gtboxes)\n",
    "    # 随机打乱真实框排列顺序\n",
    "    gtboxes, gtlabels = shuffle_gtbox(gtboxes, gtlabels)\n",
    "\n",
    "    return img.astype('float32'), gtboxes.astype('float32'), gtlabels.astype('int32')\n",
    "\n",
    "img_enhance, img_box, img_label = image_augment(srcimg, srcimg_gtbox, srcimg_label, size=320)\n",
    "visualize(srcimg, img_enhance)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img, gt_boxes, gt_labels, scales = get_img_data_from_file(record)\n",
    "size = 512\n",
    "img, gt_boxes, gt_labels = image_augment(img, gt_boxes, gt_labels, size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(512, 512, 3)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(50, 4)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gt_boxes.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(50,)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gt_labels.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里得到的img数据数值需要调整，需要除以255，并且减去均值和方差，再将维度从[H, W, C]调整为[C, H, W]。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img, gt_boxes, gt_labels, scales = get_img_data_from_file(record)\n",
    "size = 512\n",
    "img, gt_boxes, gt_labels = image_augment(img, gt_boxes, gt_labels, size)\n",
    "mean = [0.485, 0.456, 0.406]\n",
    "std = [0.229, 0.224, 0.225]\n",
    "mean = np.array(mean).reshape((1, 1, -1))\n",
    "std = np.array(std).reshape((1, 1, -1))\n",
    "img = (img / 255.0 - mean) / std\n",
    "img = img.astype('float32').transpose((2, 0, 1))\n",
    "img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将上面的过程整理成一个`get_img_data`函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_img_data(record, size=640):\n",
    "    img, gt_boxes, gt_labels, scales = get_img_data_from_file(record)\n",
    "    img, gt_boxes, gt_labels = image_augment(img, gt_boxes, gt_labels, size)\n",
    "    mean = [0.485, 0.456, 0.406]\n",
    "    std = [0.229, 0.224, 0.225]\n",
    "    mean = np.array(mean).reshape((1, 1, -1))\n",
    "    std = np.array(std).reshape((1, 1, -1))\n",
    "    img = (img / 255.0 - mean) / std\n",
    "    img = img.astype('float32').transpose((2, 0, 1))\n",
    "    return img, gt_boxes, gt_labels, scales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TRAINDIR = '/home/aistudio/work/insects/train'\n",
    "TESTDIR = '/home/aistudio/work/insects/test'\n",
    "VALIDDIR = '/home/aistudio/work/insects/val'\n",
    "cname2cid = get_insect_names()\n",
    "records = get_annotations(cname2cid, TRAINDIR)\n",
    "\n",
    "record = records[0]\n",
    "img, gt_boxes, gt_labels, scales = get_img_data(record, size=480)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 480, 480)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(50, 4)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gt_boxes.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 4, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0,\n",
       "       6, 0, 0, 0, 0, 0], dtype=int32)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gt_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1504.0, 1504.0)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用飞桨高层API快速实现数据增强\n",
    "上述代码中，我们使用numpy实现了多种数据增强方式。同时飞桨也提供了**拿来即用**的数据增强方法，详细可查阅[paddle.vision.transforms](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc1/api/paddle/vision/ops/yolo_box_cn.html)模块，transforms模块中提供了数十种数据增强方式，包括亮度增强([adjust_brightness](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc1/api/paddle/vision/transforms/functional/adjust_brightness_cn.html))，对比度增强([adjust_contrast](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc1/api/paddle/vision/transforms/functional/adjust_contrast.html))，随机裁剪([RandomCrop](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc1/api/paddle/vision/transforms/transforms/RandomCrop_cn.html))等等。更多的关于高层API的使用方法，请登录飞桨官网。\n",
    "\n",
    "paddle.vision.transforms模块中的数据增强使用方式如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x864 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#对图像随机裁剪\n",
    "# 从paddle.vision.transforms模块中import随机剪切的API RandomCrop\n",
    "from paddle.vision.transforms import RandomCrop\n",
    "\n",
    "# RandomCrop是一个python类，需要事先声明\n",
    "#RandomCrop还需要传入剪切的形状，这里设置为640\n",
    "transform = RandomCrop(640)\n",
    "# 将图像转换为PIL.Image格式\n",
    "srcimg = Image.fromarray(np.array(srcimg))\n",
    "# 调用声明好的API实现随机剪切\n",
    "img_res = transform(srcimg)\n",
    "# 可视化结果\n",
    "visualize(srcimg, np.array(img_res))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同样的方法，可以用飞桨高层API实现亮度增强，如下代码所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x864 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from paddle.vision.transforms import BrightnessTransform\n",
    "\n",
    "# BrightnessTransform是一个python类，需要事先声明\n",
    "transform = BrightnessTransform(0.4)\n",
    "# 将图像转换为PIL.Image格式\n",
    "srcimg = Image.fromarray(np.array(srcimg))\n",
    "# 调用声明好的API实现随机剪切\n",
    "img_res = transform(srcimg)\n",
    "# 可视化结果\n",
    "visualize(srcimg, np.array(img_res))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 批量数据读取与加速\n",
    "\n",
    "上面的程序展示了如何读取一张图片的数据并加速，下面的代码实现了批量数据读取。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 获取一个批次内样本随机缩放的尺寸\n",
    "def get_img_size(mode):\n",
    "    if (mode == 'train') or (mode == 'valid'):\n",
    "        inds = np.array([0,1,2,3,4,5,6,7,8,9])\n",
    "        ii = np.random.choice(inds)\n",
    "        img_size = 320 + ii * 32\n",
    "    else:\n",
    "        img_size = 608\n",
    "    return img_size\n",
    "\n",
    "# 将 list形式的batch数据 转化成多个array构成的tuple\n",
    "def make_array(batch_data):\n",
    "    img_array = np.array([item[0] for item in batch_data], dtype = 'float32')\n",
    "    gt_box_array = np.array([item[1] for item in batch_data], dtype = 'float32')\n",
    "    gt_labels_array = np.array([item[2] for item in batch_data], dtype = 'int32')\n",
    "    img_scale = np.array([item[3] for item in batch_data], dtype='int32')\n",
    "    return img_array, gt_box_array, gt_labels_array, img_scale"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于数据预处理耗时较长，可能会成为网络训练速度的瓶颈，所以需要对预处理部分进行优化。通过使用飞桨提供的[paddle.io.DataLoader](https://www.paddlepaddle.org.cn/documentation/docs/en/develop/api/paddle/io/DataLoader_en.html) API中的num_workers参数设置进程数量，实现多进程读取数据，具体实现代码如下。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import paddle\n",
    "\n",
    "# 定义数据读取类，继承Paddle.io.Dataset\n",
    "class TrainDataset(paddle.io.Dataset):\n",
    "    def  __init__(self, datadir, mode='train'):\n",
    "        self.datadir = datadir\n",
    "        cname2cid = get_insect_names()\n",
    "        self.records = get_annotations(cname2cid, datadir)\n",
    "        self.img_size = 640  #get_img_size(mode)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        record = self.records[idx]\n",
    "        # print(\"print: \", record)\n",
    "        img, gt_bbox, gt_labels, im_shape = get_img_data(record, size=self.img_size)\n",
    "\n",
    "        return img, gt_bbox, gt_labels, np.array(im_shape)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.records)\n",
    "\n",
    "# 创建数据读取类\n",
    "train_dataset = TrainDataset(TRAINDIR, mode='train')\n",
    "\n",
    "# 使用paddle.io.DataLoader创建数据读取器，并设置batchsize，进程数量num_workers等参数\n",
    "train_loader = paddle.io.DataLoader(train_dataset, batch_size=2, shuffle=True, num_workers=2, drop_last=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = paddle.io.DataLoader(train_dataset, batch_size=2, shuffle=True, num_workers=1, drop_last=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img, gt_boxes, gt_labels, im_shape = next(d())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([2, 3, 640, 640], [2, 50, 4], [2, 50], [2, 2])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img.shape, gt_boxes.shape, gt_labels.shape, im_shape.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "至此，我们完成了如何查看数据集中的数据、提取数据标注信息、从文件读取图像和标注数据、图像增广、批量读取和加速等过程，通过`paddle.io.Dataset`可以返回img, gt_boxes, gt_labels, im_shape等数据，接下来就可以将它们输入到神经网络，应用到具体算法上了。\n",
    "\n",
    "在开始具体的算法讲解之前，先补充一下读取测试数据的代码。测试数据没有标注信息，也不需要做图像增广，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "# 将 list形式的batch数据 转化成多个array构成的tuple\n",
    "def make_test_array(batch_data):\n",
    "    img_name_array = np.array([item[0] for item in batch_data])\n",
    "    img_data_array = np.array([item[1] for item in batch_data], dtype = 'float32')\n",
    "    img_scale_array = np.array([item[2] for item in batch_data], dtype='int32')\n",
    "    return img_name_array, img_data_array, img_scale_array\n",
    "\n",
    "# 测试数据读取\n",
    "def test_data_loader(datadir, batch_size= 10, test_image_size=608, mode='test'):\n",
    "    \"\"\"\n",
    "    加载测试用的图片，测试数据没有groundtruth标签\n",
    "    \"\"\"\n",
    "    image_names = os.listdir(datadir)\n",
    "    def reader():\n",
    "        batch_data = []\n",
    "        img_size = test_image_size\n",
    "        for image_name in image_names:\n",
    "            file_path = os.path.join(datadir, image_name)\n",
    "            img = cv2.imread(file_path)\n",
    "            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "            H = img.shape[0]\n",
    "            W = img.shape[1]\n",
    "            img = cv2.resize(img, (img_size, img_size))\n",
    "\n",
    "            mean = [0.485, 0.456, 0.406]\n",
    "            std = [0.229, 0.224, 0.225]\n",
    "            mean = np.array(mean).reshape((1, 1, -1))\n",
    "            std = np.array(std).reshape((1, 1, -1))\n",
    "            out_img = (img / 255.0 - mean) / std\n",
    "            out_img = out_img.astype('float32').transpose((2, 0, 1))\n",
    "            img = out_img #np.transpose(out_img, (2,0,1))\n",
    "            im_shape = [H, W]\n",
    "\n",
    "            batch_data.append((image_name.split('.')[0], img, im_shape))\n",
    "            if len(batch_data) == batch_size:\n",
    "                yield make_test_array(batch_data)\n",
    "                batch_data = []\n",
    "        if len(batch_data) > 0:\n",
    "            yield make_test_array(batch_data)\n",
    "\n",
    "    return reader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 单阶段目标检测模型YOLOv3\n",
    "\n",
    "R-CNN系列算法需要先产生候选区域，再对候选区域做分类和位置坐标的预测，这类算法被称为两阶段目标检测算法。近几年，很多研究人员相继提出一系列单阶段的检测算法，只需要一个网络即可同时产生候选区域并预测出物体的类别和位置坐标。\n",
    "\n",
    "与R-CNN系列算法不同，YOLOv3使用单个网络结构，在产生候选区域的同时即可预测出物体类别和位置，不需要分成两阶段来完成检测任务。另外，YOLOv3算法产生的预测框数目比Faster R-CNN少很多。Faster R-CNN中每个真实框可能对应多个标签为正的候选区域，而YOLOv3里面每个真实框只对应一个正的候选区域。这些特性使得YOLOv3算法具有更快的速度，能到达实时响应的水平。\n",
    "\n",
    "Joseph Redmon等人在2015年提出YOLO（You Only Look Once，YOLO）算法，通常也被称为YOLOv1；2016年，他们对算法进行改进，又提出YOLOv2版本；2018年发展出YOLOv3版本。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## YOLOv3模型设计思想\n",
    "\n",
    "YOLOv3算法的基本思想可以分成两部分：\n",
    "\n",
    "* 按一定规则在图片上产生一系列的候选区域，然后根据这些候选区域与图片上物体真实框之间的位置关系对候选区域进行标注。跟真实框足够接近的那些候选区域会被标注为正样本，同时将真实框的位置作为正样本的位置目标。偏离真实框较大的那些候选区域则会被标注为负样本，负样本不需要预测位置或者类别。\n",
    "* 使用卷积神经网络提取图片特征并对候选区域的位置和类别进行预测。这样每个预测框就可以看成是一个样本，根据真实框相对它的位置和类别进行了标注而获得标签值，通过网络模型预测其位置和类别，将网络预测值和标签值进行比较，就可以建立起损失函数。\n",
    "\n",
    "YOLOv3算法训练过程的流程图如 **图8** 所示：\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/f2eb2b75bb5a4e518b86a257e0f931de7377dba3bba44d1e846b307036aed41a\" width = \"800\"></center>\n",
    "<center><br>图8：YOLOv3算法训练流程图 </br></center>\n",
    "<br></br>\n",
    "\n",
    "\n",
    "* **图8** 左边是输入图片，上半部分所示的过程是使用卷积神经网络对图片提取特征，随着网络不断向前传播，特征图的尺寸越来越小，每个像素点会代表更加抽象的特征模式，直到输出特征图，其尺寸减小为原图的$\\frac{1}{32}$。\n",
    "* **图8** 下半部分描述了生成候选区域的过程，首先将原图划分成多个小方块，每个小方块的大小是$32 \\times 32$，然后以每个小方块为中心分别生成一系列锚框，整张图片都会被锚框覆盖到。在每个锚框的基础上产生一个与之对应的预测框，根据锚框和预测框与图片上物体真实框之间的位置关系，对这些预测框进行标注。\n",
    "* 将上方支路中输出的特征图与下方支路中产生的预测框标签建立关联，创建损失函数，开启端到端的训练过程。\n",
    "\n",
    "接下来具体介绍流程中各节点的原理和代码实现。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 产生候选区域\n",
    "\n",
    "如何产生候选区域，是检测模型的核心设计方案。目前大多数基于卷积神经网络的模型所采用的方式大体如下：\n",
    "\n",
    "* 按一定的规则在图片上生成一系列位置固定的锚框，将这些锚框看作是可能的候选区域。\n",
    "* 对锚框是否包含目标物体进行预测，如果包含目标物体，还需要预测所包含物体的类别，以及预测框相对于锚框位置需要调整的幅度。\n",
    "\n",
    "\n",
    "### 生成锚框\n",
    "\n",
    "将原始图片划分成$m\\times n$个区域，如下图所示，原始图片高度$H=640$, 宽度$W=480$，如果我们选择小块区域的尺寸为$32 \\times 32$，则$m$和$n$分别为：\n",
    "\n",
    "$$m = \\frac{640}{32} = 20$$\n",
    "\n",
    "$$n = \\frac{480}{32} = 15$$\n",
    "\n",
    "如 **图9** 所示，将原始图像分成了20行15列小方块区域。\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/2dd1cbeb53644552a8cb38f3f834dbdda5046a489465454d93cdc88d1ce65ca5\" width = \"400\"></center>\n",
    "<center><br>图9：将图片划分成多个32x32的小方块 </br></center>\n",
    "<br></br>\n",
    "\n",
    "\n",
    "YOLOv3算法会在每个区域的中心，生成一系列锚框。为了展示方便，我们先在图中第十行第四列的小方块位置附近画出生成的锚框，如 **图10** 所示。\n",
    "\n",
    "------\n",
    "**注意：**\n",
    "\n",
    "这里为了跟程序中的编号对应，最上面的行号是第0行，最左边的列号是第0列。\n",
    "\n",
    "------\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/6dd42b9138364a379b6231ac2247d3cb449d612e17be4896986bca2703acbb29\" width = \"400\"></center>\n",
    "<center><br>图10：在第10行第4列的小方块区域生成3个锚框 </br></center>\n",
    "<br></br>\n",
    "\n",
    "**图11** 展示在每个区域附近都生成3个锚框，很多锚框堆叠在一起可能不太容易看清楚，但过程跟上面类似，只是需要以每个区域的中心点为中心，分别生成3个锚框。\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/0880c3b5ec2d40edb476f4fcbadd87aa9f37059cd24d4a1a9d37c627ce5f618a\" width = \"400\"></center>\n",
    "<center><br>图11：在每个小方块区域生成3个锚框 </br></center>\n",
    "<br></br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 生成预测框\n",
    "\n",
    "在前面已经指出，锚框的位置都是固定好的，不可能刚好跟物体边界框重合，需要在锚框的基础上进行位置的微调以生成预测框。预测框相对于锚框会有不同的中心位置和大小，采用什么方式能得到预测框呢？我们先来考虑如何生成其中心位置坐标。\n",
    "\n",
    "比如上面图中在第10行第4列的小方块区域中心生成的一个锚框，如绿色虚线框所示。以小方格的宽度为单位长度，\n",
    "\n",
    "此小方块区域左上角的位置坐标是：\n",
    "$$c_x = 4$$\n",
    "$$c_y = 10$$\n",
    "\n",
    "此锚框的区域中心坐标是：\n",
    "$$center\\_x = c_x + 0.5 = 4.5$$\n",
    "$$center\\_y = c_y + 0.5 = 10.5$$\n",
    "\n",
    "可以通过下面的方式生成预测框的中心坐标：\n",
    "$$b_x = c_x + \\sigma(t_x)$$\n",
    "$$b_y = c_y + \\sigma(t_y)$$\n",
    "\n",
    "其中$t_x$和$t_y$为实数，$\\sigma(x)$是我们之前学过的Sigmoid函数，其定义如下：\n",
    "\n",
    "$$\\sigma(x) = \\frac{1}{1 + exp(-x)}$$\n",
    "\n",
    "由于Sigmoid的函数值在$0 \\thicksim 1$之间，因此由上面公式计算出来的预测框的中心点总是落在第十行第四列的小区域内部。\n",
    "\n",
    "当$t_x=t_y=0$时，$b_x = c_x + 0.5$，$b_y = c_y + 0.5$，预测框中心与锚框中心重合，都是小区域的中心。\n",
    "\n",
    "锚框的大小是预先设定好的，在模型中可以当作是超参数，下图中画出的锚框尺寸是\n",
    "\n",
    "$$p_h = 350$$\n",
    "$$p_w = 250$$\n",
    "\n",
    "通过下面的公式生成预测框的大小：\n",
    "\n",
    "$$b_h = p_h e^{t_h}$$\n",
    "$$b_w = p_w e^{t_w}$$\n",
    "\n",
    "如果$t_x=t_y=0, t_h=t_w=0$，则预测框跟锚框重合。\n",
    "\n",
    "如果给$t_x, t_y, t_h, t_w$随机赋值如下：\n",
    "\n",
    "$$t_x = 0.2,  t_y = 0.3, t_w = 0.1, t_h = -0.12$$\n",
    "\n",
    "则可以得到预测框的坐标是(154.98, 357.44, 276.29, 310.42)，如 **图12** 中蓝色框所示。\n",
    "\n",
    "------\n",
    "**说明：**\n",
    "这里坐标采用$xywh$的格式。\n",
    "\n",
    "-------\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/f4b33522eb5a45f0804b94a5c66b76a0a2d13345d6de499399580a031b6ccc74\" width = \"400\"></center>\n",
    "<center><br>图12：生成预测框 </br></center>\n",
    "<br></br>\n",
    "\n",
    "这里我们会问：当$t_x, t_y, t_w, t_h$取值为多少的时候，预测框能够跟真实框重合？为了回答问题，只需要将上面预测框坐标中的$b_x, b_y, b_h, b_w$设置为真实框的位置，即可求解出$t$的数值。\n",
    "\n",
    "令：\n",
    "$$\\sigma(t^*_x) + c_x = gt_x$$\n",
    "$$\\sigma(t^*_y) + c_y = gt_y$$\n",
    "$$p_w e^{t^*_w} = gt_h$$\n",
    "$$p_h e^{t^*_h} = gt_w$$\n",
    "\n",
    "可以求解出：$(t^*_x, t^*_y, t^*_w, t^*_h)$\n",
    "\n",
    "如果$t$是网络预测的输出值，将$t^*$作为目标值，以他们之间的差距作为损失函数，则可以建立起一个回归问题，通过学习网络参数，使得$t$足够接近$t^*$，从而能够求解出预测框的位置坐标和大小。\n",
    "\n",
    "预测框可以看作是在锚框基础上的一个微调，每个锚框会有一个跟它对应的预测框，我们需要确定上面计算式中的$t_x, t_y, t_w, t_h$，从而计算出与锚框对应的预测框的位置和形状。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 对候选区域进行标注\n",
    "\n",
    "每个区域可以产生3种不同形状的锚框，每个锚框都是一个可能的候选区域，对这些候选区域我们需要了解如下几件事情：\n",
    "\n",
    "- 锚框是否包含物体，这可以看成是一个二分类问题，使用标签objectness来表示。当锚框包含了物体时，objectness=1，表示预测框属于正类；当锚框不包含物体时，设置objectness=0，表示锚框属于负类。\n",
    "\n",
    "- 如果锚框包含了物体，那么它对应的预测框的中心位置和大小应该是多少，或者说上面计算式中的$t_x, t_y, t_w, t_h$应该是多少，使用location标签。\n",
    "\n",
    "- 如果锚框包含了物体，那么具体类别是什么，这里使用变量label来表示其所属类别的标签。\n",
    "\n",
    "选取任意一个锚框对它进行标注，也就是需要确定其对应的objectness, $(t_x, t_y, t_w, t_h)$和label，下面将分别讲述如何确定这三个标签的值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 标注锚框是否包含物体\n",
    "\n",
    "如 **图13** 所示，这里一共有3个目标，以最左边的人像为例，其真实框是$(133.96, 328.4, 186.06, 374.63)$。\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/f21679e68d2b496698ed788a16d4ea2e5bc6f82b253a44ef9508b6a4fc9b6be4\" width = \"600\"></center>\n",
    "<center><br>图13：选出与真实框中心位于同一区域的锚框 </br></center>\n",
    "<br></br>\n",
    "\n",
    "真实框的中心点坐标是：\n",
    "\n",
    "$$ center\\_x = 133.96$$\n",
    "\n",
    "$$ center\\_y = 328.42$$\n",
    "\n",
    "$$ i = 133.96 / 32 = 4.18625$$\n",
    "\n",
    "$$ j = 328.42 / 32 = 10.263125$$\n",
    "\n",
    "它落在了第10行第4列的小方块内，如**图13**所示。此小方块区域可以生成3个不同形状的锚框，其在图上的编号和大小分别是$A_1(116, 90), A_2(156, 198), A_3(373, 326)$。\n",
    "\n",
    "用这3个不同形状的锚框跟真实框计算IoU，选出IoU最大的锚框。这里为了简化计算，只考虑锚框的形状，不考虑其跟真实框中心之间的偏移，具体计算结果如 **图14** 所示。\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/3008337ea66c44068042c670db54368edc56b1e43ced4b6b811bdc95b64ca3d5\" width = \"400\"></center>\n",
    "<center><br>图14：选出与真实框与锚框的IoU </br></center>\n",
    "<br></br>\n",
    "\n",
    "其中跟真实框IoU最大的是锚框$A_3$，形状是$(373, 326)$，将它所对应的预测框的objectness标签设置为1，其所包括的物体类别就是真实框里面的物体所属类别。\n",
    "\n",
    "依次可以找出其他几个真实框对应的IoU最大的锚框，然后将它们的预测框的objectness标签也都设置为1。这里一共有$20 \\times 15 \\times 3 = 900$个锚框，只有3个预测框会被标注为正。\n",
    "\n",
    "由于每个真实框只对应一个objectness标签为正的预测框，如果有些预测框跟真实框之间的IoU很大，但并不是最大的那个，那么直接将其objectness标签设置为0当作负样本，可能并不妥当。为了避免这种情况，YOLOv3算法设置了一个IoU阈值iou_threshold，当预测框的objectness不为1，但是其与某个真实框的IoU大于iou_threshold时，就将其objectness标签设置为-1，不参与损失函数的计算。\n",
    "\n",
    "所有其他的预测框，其objectness标签均设置为0，表示负类。\n",
    "\n",
    "对于objectness=1的预测框，需要进一步确定其位置和包含物体的具体分类标签，但是对于objectness=0或者-1的预测框，则不用管他们的位置和类别。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 标注预测框的位置坐标标签\n",
    "\n",
    "当锚框objectness=1时，需要确定预测框位置相对于它微调的幅度，也就是锚框的位置标签。\n",
    "\n",
    "在前面我们已经问过这样一个问题：当$t_x, t_y, t_w, t_h$取值为多少的时候，预测框能够跟真实框重合？其做法是将预测框坐标中的$b_x, b_y, b_h, b_w$设置为真实框的坐标，即可求解出$t$的数值。\n",
    "\n",
    "令：\n",
    "$$\\sigma(t^*_x) + c_x = gt_x$$\n",
    "$$\\sigma(t^*_y) + c_y = gt_y$$\n",
    "$$p_w e^{t^*_w} = gt_w$$\n",
    "$$p_h e^{t^*_h} = gt_h$$\n",
    "\n",
    "对于$t_x^*$和$t_y^*$，由于Sigmoid的反函数不好计算，我们直接使用$\\sigma(t^*_x)$和$\\sigma(t^*_y)$作为回归的目标。\n",
    "\n",
    "$$d_x^* = \\sigma(t^*_x) = gt_x - c_x$$\n",
    "\n",
    "$$d_y^* = \\sigma(t^*_y) = gt_y - c_y$$\n",
    "\n",
    "$$t^*_w = log(\\frac{gt_w}{p_w})$$\n",
    "\n",
    "$$t^*_h = log(\\frac{gt_h}{p_h})$$\n",
    "\n",
    "如果$(t_x, t_y, t_h, t_w)$是网络预测的输出值，将$(d_x^*, d_y^*, t_w^*, t_h^*)$作为$(\\sigma(t_x), \\sigma(t_y), t_h, t_w)$的目标值，以它们之间的差距作为损失函数，则可以建立起一个回归问题，通过学习网络参数，使得$t$足够接近$t^*$，从而能够求解出预测框的位置。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 标注锚框包含物体类别的标签\n",
    "\n",
    "对于objectness=1的锚框，需要确定其具体类别。正如上面所说，objectness标注为1的锚框，会有一个真实框跟它对应，该锚框所属物体类别，即是其所对应的真实框包含的物体类别。这里使用one-hot向量来表示类别标签label。比如一共有10个分类，而真实框里面包含的物体类别是第2类，则label为$(0,1,0,0,0,0,0,0,0,0)$\n",
    "\n",
    "对上述步骤进行总结，标注的流程如 **图15** 所示。\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/3b914be0c6274916bc7abe4922d4d0fb75be340172764f7096af5be0c2737c57\" width = \"700\"></center>\n",
    "<center><br>图15：标注流程示意图 </br></center>\n",
    "<br></br>\n",
    "\n",
    "通过这种方式，我们在每个小方块区域都生成了一系列的锚框作为候选区域，并且根据图片上真实物体的位置，标注出了每个候选区域对应的objectness标签、位置需要调整的幅度以及包含的物体所属的类别。位置需要调整的幅度由4个变量描述$(t_x, t_y, t_w, t_h)$，objectness标签需要用一个变量描述$obj$，描述所属类别的变量长度等于类别数C。\n",
    "\n",
    "对于每个锚框，模型需要预测输出$(t_x, t_y, t_w, t_h, P_{obj}, P_1, P_2,... , P_C)$，其中$P_{obj}$是锚框是否包含物体的概率，$P_1, P_2,... , P_C$则是锚框包含的物体属于每个类别的概率。接下来让我们一起学习如何通过卷积神经网络输出这样的预测值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 标注锚框的具体程序\n",
    "\n",
    "上面描述了如何对预锚框进行标注，但读者可能仍然对里面的细节不太了解，下面将通过具体的程序完成这一步骤。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 标注预测框的objectness\n",
    "def get_objectness_label(img, gt_boxes, gt_labels, iou_threshold = 0.7,\n",
    "                         anchors = [116, 90, 156, 198, 373, 326],\n",
    "                         num_classes=7, downsample=32):\n",
    "    \"\"\"\n",
    "    img 是输入的图像数据，形状是[N, C, H, W]\n",
    "    gt_boxes，真实框，维度是[N, 50, 4]，其中50是真实框数目的上限，当图片中真实框不足50个时，不足部分的坐标全为0\n",
    "              真实框坐标格式是xywh，这里使用相对值\n",
    "    gt_labels，真实框所属类别，维度是[N, 50]\n",
    "    iou_threshold，当预测框与真实框的iou大于iou_threshold时不将其看作是负样本\n",
    "    anchors，锚框可选的尺寸\n",
    "    anchor_masks，通过与anchors一起确定本层级的特征图应该选用多大尺寸的锚框\n",
    "    num_classes，类别数目\n",
    "    downsample，特征图相对于输入网络的图片尺寸变化的比例\n",
    "    \"\"\"\n",
    "\n",
    "    img_shape = img.shape\n",
    "    batchsize = img_shape[0]\n",
    "    num_anchors = len(anchors) // 2\n",
    "    input_h = img_shape[2]\n",
    "    input_w = img_shape[3]\n",
    "    # 将输入图片划分成num_rows x num_cols个小方块区域，每个小方块的边长是 downsample\n",
    "    # 计算一共有多少行小方块\n",
    "    num_rows = input_h // downsample\n",
    "    # 计算一共有多少列小方块\n",
    "    num_cols = input_w // downsample\n",
    "\n",
    "    label_objectness = np.zeros([batchsize, num_anchors, num_rows, num_cols])\n",
    "    label_classification = np.zeros([batchsize, num_anchors, num_classes, num_rows, num_cols])\n",
    "    label_location = np.zeros([batchsize, num_anchors, 4, num_rows, num_cols])\n",
    "\n",
    "    scale_location = np.ones([batchsize, num_anchors, num_rows, num_cols])\n",
    "\n",
    "    # 对batchsize进行循环，依次处理每张图片\n",
    "    for n in range(batchsize):\n",
    "        # 对图片上的真实框进行循环，依次找出跟真实框形状最匹配的锚框\n",
    "        for n_gt in range(len(gt_boxes[n])):\n",
    "            gt = gt_boxes[n][n_gt]\n",
    "            gt_cls = gt_labels[n][n_gt]\n",
    "            gt_center_x = gt[0]\n",
    "            gt_center_y = gt[1]\n",
    "            gt_width = gt[2]\n",
    "            gt_height = gt[3]\n",
    "            if (gt_width < 1e-3) or (gt_height < 1e-3):\n",
    "                continue\n",
    "            i = int(gt_center_y * num_rows)\n",
    "            j = int(gt_center_x * num_cols)\n",
    "            ious = []\n",
    "            for ka in range(num_anchors):\n",
    "                bbox1 = [0., 0., float(gt_width), float(gt_height)]\n",
    "                anchor_w = anchors[ka * 2]\n",
    "                anchor_h = anchors[ka * 2 + 1]\n",
    "                bbox2 = [0., 0., anchor_w/float(input_w), anchor_h/float(input_h)]\n",
    "                # 计算iou\n",
    "                iou = box_iou_xywh(bbox1, bbox2)\n",
    "                ious.append(iou)\n",
    "            ious = np.array(ious)\n",
    "            inds = np.argsort(ious)\n",
    "            k = inds[-1]\n",
    "            label_objectness[n, k, i, j] = 1\n",
    "            c = gt_cls\n",
    "            label_classification[n, k, c, i, j] = 1.\n",
    "\n",
    "            # for those prediction bbox with objectness =1, set label of location\n",
    "            dx_label = gt_center_x * num_cols - j\n",
    "            dy_label = gt_center_y * num_rows - i\n",
    "            dw_label = np.log(gt_width * input_w / anchors[k*2])\n",
    "            dh_label = np.log(gt_height * input_h / anchors[k*2 + 1])\n",
    "            label_location[n, k, 0, i, j] = dx_label\n",
    "            label_location[n, k, 1, i, j] = dy_label\n",
    "            label_location[n, k, 2, i, j] = dw_label\n",
    "            label_location[n, k, 3, i, j] = dh_label\n",
    "            # scale_location用来调节不同尺寸的锚框对损失函数的贡献，作为加权系数和位置损失函数相乘\n",
    "            scale_location[n, k, i, j] = 2.0 - gt_width * gt_height\n",
    "\n",
    "    # 目前根据每张图片上所有出现过的gt box，都标注出了objectness为正的预测框，剩下的预测框则默认objectness为0\n",
    "    # 对于objectness为1的预测框，标出了他们所包含的物体类别，以及位置回归的目标\n",
    "    return label_objectness.astype('float32'), label_location.astype('float32'), label_classification.astype('float32'), \\\n",
    "             scale_location.astype('float32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算IoU，矩形框的坐标形式为xywh\n",
    "def box_iou_xywh(box1, box2):\n",
    "    x1min, y1min = box1[0] - box1[2]/2.0, box1[1] - box1[3]/2.0\n",
    "    x1max, y1max = box1[0] + box1[2]/2.0, box1[1] + box1[3]/2.0\n",
    "    s1 = box1[2] * box1[3]\n",
    "\n",
    "    x2min, y2min = box2[0] - box2[2]/2.0, box2[1] - box2[3]/2.0\n",
    "    x2max, y2max = box2[0] + box2[2]/2.0, box2[1] + box2[3]/2.0\n",
    "    s2 = box2[2] * box2[3]\n",
    "\n",
    "    xmin = np.maximum(x1min, x2min)\n",
    "    ymin = np.maximum(y1min, y2min)\n",
    "    xmax = np.minimum(x1max, x2max)\n",
    "    ymax = np.minimum(y1max, y2max)\n",
    "    inter_h = np.maximum(ymax - ymin, 0.)\n",
    "    inter_w = np.maximum(xmax - xmin, 0.)\n",
    "    intersection = inter_h * inter_w\n",
    "\n",
    "    union = s1 + s2 - intersection\n",
    "    iou = intersection / union\n",
    "    return iou "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读取数据\n",
    "import paddle\n",
    "reader = paddle.io.DataLoader(train_dataset, batch_size=2, shuffle=True, num_workers=1, drop_last=True)\n",
    "img, gt_boxes, gt_labels, im_shape = next(reader())\n",
    "img, gt_boxes, gt_labels, im_shape = img.numpy(), gt_boxes.numpy(), gt_labels.numpy(), im_shape.numpy()\n",
    "\n",
    "# 计算出锚框对应的标签\n",
    "label_objectness, label_location, label_classification, scale_location = get_objectness_label(img,\n",
    "                                                                                              gt_boxes, gt_labels, \n",
    "                                                                                              iou_threshold = 0.7,\n",
    "                                                                                              anchors = [116, 90, 156, 198, 373, 326],\n",
    "                                                                                              num_classes=7, downsample=32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 3, 640, 640), (2, 50, 4), (2, 50), (2, 2))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img.shape, gt_boxes.shape, gt_labels.shape, im_shape.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 3, 20, 20), (2, 3, 4, 20, 20), (2, 3, 7, 20, 20), (2, 3, 20, 20))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label_objectness.shape, label_location.shape, label_classification.shape, scale_location.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的程序实现了对锚框进行标注，对于每个真实框，选出了与它形状最匹配的锚框，将其objectness标注为1，并且将$[d_x^*, d_y^*, t_h^*, t_w^*]$作为正样本位置的标签，真实框包含的物体类别作为锚框的类别。而其余的锚框，objectness将被标注为0，无需标注出位置和类别的标签。\n",
    "\n",
    "- 注意：这里还遗留一个小问题，前面我们说了对于与真实框IoU较大的那些锚框，需要将其objectness标注为-1，不参与损失函数的计算。我们先将这个问题放一放，等到后面建立损失函数的时候再补上。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 卷积神经网络提取特征\n",
    "\n",
    "在上一节图像分类的课程中，我们已经学习过了通过卷积神经网络提取图像特征。通过连续使用多层卷积和池化等操作，能得到语义含义更加丰富的特征图。在检测问题中，也使用卷积神经网络逐层提取图像特征，通过最终的输出特征图来表征物体位置和类别等信息。\n",
    "\n",
    "YOLOv3算法使用的骨干网络是Darknet53。Darknet53网络的具体结构如 **图16** 所示，在ImageNet图像分类任务上取得了很好的成绩。在检测任务中，将图中C0后面的平均池化、全连接层和Softmax去掉，保留从输入到C0部分的网络结构，作为检测模型的基础网络结构，也称为骨干网络。YOLOv3模型会在骨干网络的基础上，再添加检测相关的网络模块。\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/d5cb1e88d3f44259be1427a90ee454a57738ee8083ad40269f5485988526f30d\" width = \"400\"></center>\n",
    "<center><br>图16：Darknet53网络结构 </br></center>\n",
    "<br></br>\n",
    "\n",
    "下面的程序是Darknet53骨干网络的实现代码，这里将上图中C0、C1、C2所表示的输出数据取出，并查看它们的形状分别是，$C0 [1, 1024, 20, 20]$，$C1 [1, 512, 40, 40]$，$C2 [1, 256, 80, 80]$。\n",
    "\n",
    "- 名词解释：特征图的步幅(stride)\n",
    "\n",
    "在提取特征的过程中通常会使用步幅大于1的卷积或者池化，导致后面的特征图尺寸越来越小，特征图的步幅等于输入图片尺寸除以特征图尺寸。例如：C0的尺寸是$20\\times20$，原图尺寸是$640\\times640$，则C0的步幅是$\\frac{640}{20}=32$。同理，C1的步幅是16，C2的步幅是8。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import paddle\n",
    "import paddle.nn.functional as F\n",
    "import numpy as np\n",
    "\n",
    "class ConvBNLayer(paddle.nn.Layer):\n",
    "    def __init__(self, ch_in, ch_out, \n",
    "                 kernel_size=3, stride=1, groups=1,\n",
    "                 padding=0, act=\"leaky\"):\n",
    "        super(ConvBNLayer, self).__init__()\n",
    "    \n",
    "        self.conv = paddle.nn.Conv2D(\n",
    "            in_channels=ch_in,\n",
    "            out_channels=ch_out,\n",
    "            kernel_size=kernel_size,\n",
    "            stride=stride,\n",
    "            padding=padding,\n",
    "            groups=groups,\n",
    "            weight_attr=paddle.ParamAttr(\n",
    "                initializer=paddle.nn.initializer.Normal(0., 0.02)),\n",
    "            bias_attr=False)\n",
    "    \n",
    "        self.batch_norm = paddle.nn.BatchNorm2D(\n",
    "            num_features=ch_out,\n",
    "            weight_attr=paddle.ParamAttr(\n",
    "                initializer=paddle.nn.initializer.Normal(0., 0.02),\n",
    "                regularizer=paddle.regularizer.L2Decay(0.)),\n",
    "            bias_attr=paddle.ParamAttr(\n",
    "                initializer=paddle.nn.initializer.Constant(0.0),\n",
    "                regularizer=paddle.regularizer.L2Decay(0.)))\n",
    "        self.act = act\n",
    "\n",
    "        \n",
    "    def forward(self, inputs):\n",
    "        out = self.conv(inputs)\n",
    "        out = self.batch_norm(out)\n",
    "        if self.act == 'leaky':\n",
    "            out = F.leaky_relu(x=out, negative_slope=0.1)\n",
    "        return out\n",
    "    \n",
    "class DownSample(paddle.nn.Layer):\n",
    "    # 下采样，图片尺寸减半，具体实现方式是使用stirde=2的卷积\n",
    "    def __init__(self,\n",
    "                 ch_in,\n",
    "                 ch_out,\n",
    "                 kernel_size=3,\n",
    "                 stride=2,\n",
    "                 padding=1):\n",
    "\n",
    "        super(DownSample, self).__init__()\n",
    "\n",
    "        self.conv_bn_layer = ConvBNLayer(\n",
    "            ch_in=ch_in,\n",
    "            ch_out=ch_out,\n",
    "            kernel_size=kernel_size,\n",
    "            stride=stride,\n",
    "            padding=padding)\n",
    "        self.ch_out = ch_out\n",
    "    def forward(self, inputs):\n",
    "        out = self.conv_bn_layer(inputs)\n",
    "        return out\n",
    "\n",
    "class BasicBlock(paddle.nn.Layer):\n",
    "    \"\"\"\n",
    "    基本残差块的定义，输入x经过两层卷积，然后接第二层卷积的输出和输入x相加\n",
    "    \"\"\"\n",
    "    def __init__(self, ch_in, ch_out):\n",
    "        super(BasicBlock, self).__init__()\n",
    "\n",
    "        self.conv1 = ConvBNLayer(\n",
    "            ch_in=ch_in,\n",
    "            ch_out=ch_out,\n",
    "            kernel_size=1,\n",
    "            stride=1,\n",
    "            padding=0\n",
    "            )\n",
    "        self.conv2 = ConvBNLayer(\n",
    "            ch_in=ch_out,\n",
    "            ch_out=ch_out*2,\n",
    "            kernel_size=3,\n",
    "            stride=1,\n",
    "            padding=1\n",
    "            )\n",
    "    def forward(self, inputs):\n",
    "        conv1 = self.conv1(inputs)\n",
    "        conv2 = self.conv2(conv1)\n",
    "        out = paddle.add(x=inputs, y=conv2)\n",
    "        return out\n",
    "\n",
    "     \n",
    "class LayerWarp(paddle.nn.Layer):\n",
    "    \"\"\"\n",
    "    添加多层残差块，组成Darknet53网络的一个层级\n",
    "    \"\"\"\n",
    "    def __init__(self, ch_in, ch_out, count, is_test=True):\n",
    "        super(LayerWarp,self).__init__()\n",
    "\n",
    "        self.basicblock0 = BasicBlock(ch_in,\n",
    "            ch_out)\n",
    "        self.res_out_list = []\n",
    "        for i in range(1, count):\n",
    "            res_out = self.add_sublayer(\"basic_block_%d\" % (i), # 使用add_sublayer添加子层\n",
    "                BasicBlock(ch_out*2,\n",
    "                    ch_out))\n",
    "            self.res_out_list.append(res_out)\n",
    "\n",
    "    def forward(self,inputs):\n",
    "        y = self.basicblock0(inputs)\n",
    "        for basic_block_i in self.res_out_list:\n",
    "            y = basic_block_i(y)\n",
    "        return y\n",
    "\n",
    "# DarkNet 每组残差块的个数，来自DarkNet的网络结构图\n",
    "DarkNet_cfg = {53: ([1, 2, 8, 8, 4])}\n",
    "\n",
    "class DarkNet53_conv_body(paddle.nn.Layer):\n",
    "    def __init__(self):\n",
    "        super(DarkNet53_conv_body, self).__init__()\n",
    "        self.stages = DarkNet_cfg[53]\n",
    "        self.stages = self.stages[0:5]\n",
    "\n",
    "        # 第一层卷积\n",
    "        self.conv0 = ConvBNLayer(\n",
    "            ch_in=3,\n",
    "            ch_out=32,\n",
    "            kernel_size=3,\n",
    "            stride=1,\n",
    "            padding=1)\n",
    "\n",
    "        # 下采样，使用stride=2的卷积来实现\n",
    "        self.downsample0 = DownSample(\n",
    "            ch_in=32,\n",
    "            ch_out=32 * 2)\n",
    "\n",
    "        # 添加各个层级的实现\n",
    "        self.darknet53_conv_block_list = []\n",
    "        self.downsample_list = []\n",
    "        for i, stage in enumerate(self.stages):\n",
    "            conv_block = self.add_sublayer(\n",
    "                \"stage_%d\" % (i),\n",
    "                LayerWarp(32*(2**(i+1)),\n",
    "                32*(2**i),\n",
    "                stage))\n",
    "            self.darknet53_conv_block_list.append(conv_block)\n",
    "        # 两个层级之间使用DownSample将尺寸减半\n",
    "        for i in range(len(self.stages) - 1):\n",
    "            downsample = self.add_sublayer(\n",
    "                \"stage_%d_downsample\" % i,\n",
    "                DownSample(ch_in=32*(2**(i+1)),\n",
    "                    ch_out=32*(2**(i+2))))\n",
    "            self.downsample_list.append(downsample)\n",
    "\n",
    "    def forward(self,inputs):\n",
    "        out = self.conv0(inputs)\n",
    "        #print(\"conv1:\",out.numpy())\n",
    "        out = self.downsample0(out)\n",
    "        #print(\"dy:\",out.numpy())\n",
    "        blocks = []\n",
    "        for i, conv_block_i in enumerate(self.darknet53_conv_block_list): #依次将各个层级作用在输入上面\n",
    "            out = conv_block_i(out)\n",
    "            blocks.append(out)\n",
    "            if i < len(self.stages) - 1:\n",
    "                out = self.downsample_list[i](out)\n",
    "        return blocks[-1:-4:-1] # 将C0, C1, C2作为返回值\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1024, 20, 20] [1, 512, 40, 40] [1, 256, 80, 80]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/nn/layer/norm.py:636: UserWarning: When training, we now always track global mean and variance.\n",
      "  \"When training, we now always track global mean and variance.\")\n"
     ]
    }
   ],
   "source": [
    "# 查看Darknet53网络输出特征图\n",
    "import numpy as np\n",
    "backbone = DarkNet53_conv_body()\n",
    "x = np.random.randn(1, 3, 640, 640).astype('float32')\n",
    "x = paddle.to_tensor(x)\n",
    "C0, C1, C2 = backbone(x)\n",
    "print(C0.shape, C1.shape, C2.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面这段示例代码，指定输入数据的形状是$(1, 3, 640, 640)$，则3个层级的输出特征图的形状分别是$C0 (1, 1024, 20, 20)$，$C1 (1, 512, 40, 40)$和$C2 (1, 256, 80, 80)$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 根据输出特征图计算预测框位置和类别\n",
    "\n",
    "YOLOv3中对每个预测框计算逻辑如下：\n",
    "\n",
    "- 预测框是否包含物体。也可理解为objectness=1的概率是多少，可以用网络输出一个实数$x$，可以用$Sigmoid(x)$表示objectness为正的概率$P_{obj}$\n",
    "\n",
    "- 预测物体位置和形状。物体位置和形状$t_x, t_y, t_w, t_h$可以用网络输出4个实数来表示$t_x, t_y, t_w, t_h$\n",
    "\n",
    "- 预测物体类别。预测图像中物体的具体类别是什么，或者说其属于每个类别的概率分别是多少。总的类别数为C，需要预测物体属于每个类别的概率$(P_1, P_2, ..., P_C)$，可以用网络输出C个实数$(x_1, x_2, ..., x_C)$，对每个实数分别求Sigmoid函数，让$P_i = Sigmoid(x_i)$，则可以表示出物体属于每个类别的概率。\n",
    "\n",
    "\n",
    "对于一个预测框，网络需要输出$(5 + C)$个实数来表征它是否包含物体、位置和形状尺寸以及属于每个类别的概率。\n",
    "\n",
    "由于我们在每个小方块区域都生成了K个预测框，则所有预测框一共需要网络输出的预测值数目是：\n",
    "\n",
    "$$[K(5 + C)] \\times m \\times n $$\n",
    "\n",
    "还有更重要的一点是网络输出必须要能区分出小方块区域的位置来，不能直接将特征图连接一个输出大小为$[K(5 + C)] \\times m \\times n$的全连接层。\n",
    "\n",
    "### 建立输出特征图与预测框之间的关联\n",
    "\n",
    "现在观察特征图，经过多次卷积核池化之后，其步幅stride=32，$640 \\times 480$大小的输入图片变成了$20\\times15$的特征图；而小方块区域的数目正好是$20\\times15$，也就是说可以让特征图上每个像素点分别跟原图上一个小方块区域对应。这也是为什么我们最开始将小方块区域的尺寸设置为32的原因，这样可以巧妙的将小方块区域跟特征图上的像素点对应起来，解决了空间位置的对应关系。\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/59bd2592dd9f4f4dada8333307198888e667b15969ce434eb52c0232d9608a62\" width = \"600\"></center>\n",
    "<center><br>图17：特征图C0与小方块区域形状对比 </br></center>\n",
    "<br></br>\n",
    "\n",
    "下面需要将像素点$(i,j)$与第i行第j列的小方块区域所需要的预测值关联起来，每个小方块区域产生K个预测框，每个预测框需要$(5 + C)$个实数预测值，则每个像素点相对应的要有$K(5 + C)$个实数。为了解决这一问题，对特征图进行多次卷积，并将最终的输出通道数设置为$K(5 + C)$，即可将生成的特征图与每个预测框所需要的预测值巧妙的对应起来。当然，这种对应是为了将骨干网络提取的特征对接输出层来形成Loss。实际中，这几个尺寸可以随着任务数据分布的不同而调整，只要保证特征图输出尺寸（控制卷积核和下采样）和输出层尺寸（控制小方块区域的大小）相同即可。\n",
    "\n",
    "骨干网络的输出特征图是C0，下面的程序是对C0进行多次卷积以得到跟预测框相关的特征图P0。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class YoloDetectionBlock(paddle.nn.Layer):\n",
    "    # define YOLOv3 detection head\n",
    "    # 使用多层卷积和BN提取特征\n",
    "    def __init__(self,ch_in,ch_out,is_test=True):\n",
    "        super(YoloDetectionBlock, self).__init__()\n",
    "\n",
    "        assert ch_out % 2 == 0, \\\n",
    "            \"channel {} cannot be divided by 2\".format(ch_out)\n",
    "\n",
    "        self.conv0 = ConvBNLayer(\n",
    "            ch_in=ch_in,\n",
    "            ch_out=ch_out,\n",
    "            kernel_size=1,\n",
    "            stride=1,\n",
    "            padding=0)\n",
    "        self.conv1 = ConvBNLayer(\n",
    "            ch_in=ch_out,\n",
    "            ch_out=ch_out*2,\n",
    "            kernel_size=3,\n",
    "            stride=1,\n",
    "            padding=1)\n",
    "        self.conv2 = ConvBNLayer(\n",
    "            ch_in=ch_out*2,\n",
    "            ch_out=ch_out,\n",
    "            kernel_size=1,\n",
    "            stride=1,\n",
    "            padding=0)\n",
    "        self.conv3 = ConvBNLayer(\n",
    "            ch_in=ch_out,\n",
    "            ch_out=ch_out*2,\n",
    "            kernel_size=3,\n",
    "            stride=1,\n",
    "            padding=1)\n",
    "        self.route = ConvBNLayer(\n",
    "            ch_in=ch_out*2,\n",
    "            ch_out=ch_out,\n",
    "            kernel_size=1,\n",
    "            stride=1,\n",
    "            padding=0)\n",
    "        self.tip = ConvBNLayer(\n",
    "            ch_in=ch_out,\n",
    "            ch_out=ch_out*2,\n",
    "            kernel_size=3,\n",
    "            stride=1,\n",
    "            padding=1)\n",
    "    def forward(self, inputs):\n",
    "        out = self.conv0(inputs)\n",
    "        out = self.conv1(out)\n",
    "        out = self.conv2(out)\n",
    "        out = self.conv3(out)\n",
    "        route = self.route(out)\n",
    "        tip = self.tip(route)\n",
    "        return route, tip\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 36, 20, 20]\n"
     ]
    }
   ],
   "source": [
    "NUM_ANCHORS = 3\n",
    "NUM_CLASSES = 7\n",
    "num_filters=NUM_ANCHORS * (NUM_CLASSES + 5)\n",
    "\n",
    "backbone = DarkNet53_conv_body()\n",
    "detection = YoloDetectionBlock(ch_in=1024, ch_out=512)\n",
    "conv2d_pred = paddle.nn.Conv2D(in_channels=1024, out_channels=num_filters, kernel_size=1)\n",
    "\n",
    "x = np.random.randn(1, 3, 640, 640).astype('float32')\n",
    "x = paddle.to_tensor(x)\n",
    "C0, C1, C2 = backbone(x)\n",
    "route, tip = detection(C0)\n",
    "P0 = conv2d_pred(tip)\n",
    "\n",
    "print(P0.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如上面的代码所示，可以由特征图C0生成特征图P0，P0的形状是$[1, 36, 20, 20]$。每个小方块区域生成的锚框或者预测框的数量是3，物体类别数目是7，每个区域需要的预测值个数是$3 \\times (5 + 7) = 36$，正好等于P0的输出通道数。\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/9ea44b2c11f74f1484ab2bdc93be4008008cdee0b8d34dcb97bc9f89af935d1c\" width = \"800\"></center>\n",
    "<center><br>图18：特征图P0与候选区域的关联 </br></center>\n",
    "<br></br>\n",
    "\n",
    "将$P0[t, 0:12, i, j]$与输入的第t张图片上小方块区域$(i, j)$第1个预测框所需要的12个预测值对应，$P0[t, 12:24, i, j]$与输入的第t张图片上小方块区域$(i, j)$第2个预测框所需要的12个预测值对应，$P0[t, 24:36, i, j]$与输入的第t张图片上小方块区域$(i, j)$第3个预测框所需要的12个预测值对应。\n",
    "\n",
    "$P0[t, 0:4, i, j]$与输入的第t张图片上小方块区域$(i, j)$第1个预测框的位置对应，$P0[t, 4, i, j]$与输入的第t张图片上小方块区域$(i, j)$第1个预测框的objectness对应，$P0[t, 5:12, i, j]$与输入的第t张图片上小方块区域$(i, j)$第1个预测框的类别对应。\n",
    "\n",
    "如 **图18** 所示，通过这种方式可以巧妙的将网络输出特征图，与每个小方块区域生成的预测框对应起来了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计算预测框是否包含物体的概率\n",
    "\n",
    "根据前面的分析，$P0[t, 4, i, j]$与输入的第t张图片上小方块区域$(i, j)$第1个预测框的objectness对应，$P0[t, 4+12, i, j]$与第2个预测框的objectness对应，...，则可以使用下面的程序将objectness相关的预测取出，并使用`paddle.nn.functional.sigmoid`计算输出概率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 20, 20] [1, 3, 20, 20]\n"
     ]
    }
   ],
   "source": [
    "NUM_ANCHORS = 3\n",
    "NUM_CLASSES = 7\n",
    "num_filters=NUM_ANCHORS * (NUM_CLASSES + 5)\n",
    "\n",
    "backbone = DarkNet53_conv_body()\n",
    "detection = YoloDetectionBlock(ch_in=1024, ch_out=512)\n",
    "conv2d_pred = paddle.nn.Conv2D(in_channels=1024, out_channels=num_filters,  kernel_size=1)\n",
    "\n",
    "x = np.random.randn(1, 3, 640, 640).astype('float32')\n",
    "x = paddle.to_tensor(x)\n",
    "C0, C1, C2 = backbone(x)\n",
    "route, tip = detection(C0)\n",
    "P0 = conv2d_pred(tip)\n",
    "\n",
    "reshaped_p0 = paddle.reshape(P0, [-1, NUM_ANCHORS, NUM_CLASSES + 5, P0.shape[2], P0.shape[3]])\n",
    "pred_objectness = reshaped_p0[:, :, 4, :, :]\n",
    "pred_objectness_probability = F.sigmoid(pred_objectness)\n",
    "print(pred_objectness.shape, pred_objectness_probability.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的输出程序显示，预测框是否包含物体的概率`pred_objectness_probability`，其数据形状是$[1, 3, 20, 20] $，与我们上面提到的预测框个数一致，数据大小在0～1之间，表示预测框为正样本的概率。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计算预测框位置坐标\n",
    "\n",
    "$P0[t, 0:4, i, j]$与输入的第$t$张图片上小方块区域$(i, j)$第1个预测框的位置对应，$P0[t, 12:16, i, j]$与第2个预测框的位置对应，...，使用下面的程序可以从$P0$中取出跟预测框位置相关的预测值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 4, 20, 20]\n"
     ]
    }
   ],
   "source": [
    "NUM_ANCHORS = 3\n",
    "NUM_CLASSES = 7\n",
    "num_filters=NUM_ANCHORS * (NUM_CLASSES + 5)\n",
    "\n",
    "backbone = DarkNet53_conv_body()\n",
    "detection = YoloDetectionBlock(ch_in=1024, ch_out=512)\n",
    "conv2d_pred =  paddle.nn.Conv2D(in_channels=1024, out_channels=num_filters,  kernel_size=1)\n",
    "\n",
    "x = np.random.randn(1, 3, 640, 640).astype('float32')\n",
    "x = paddle.to_tensor(x)\n",
    "C0, C1, C2 = backbone(x)\n",
    "route, tip = detection(C0)\n",
    "P0 = conv2d_pred(tip)\n",
    "\n",
    "\n",
    "reshaped_p0 = paddle.reshape(P0, [-1, NUM_ANCHORS, NUM_CLASSES + 5, P0.shape[2], P0.shape[3]])\n",
    "pred_objectness = reshaped_p0[:, :, 4, :, :]\n",
    "pred_objectness_probability = F.sigmoid(pred_objectness)\n",
    "\n",
    "pred_location = reshaped_p0[:, :, 0:4, :, :]\n",
    "print(pred_location.shape)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "网络输出值是$(t_x, t_y, t_h, t_w)$，还需要将其转化为$(x_1, y_1, x_2, y_2)$这种形式的坐标表示。使用飞桨[paddle.vision.ops.yolo_box](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc1/api/paddle/vision/ops/yolo_box_cn.html) API可以直接计算出结果，但为了给读者更清楚的展示算法的实现过程，我们使用Numpy来实现这一过程。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义Sigmoid函数\n",
    "def sigmoid(x):\n",
    "    return 1./(1.0 + np.exp(-x))\n",
    "\n",
    "# 将网络特征图输出的[tx, ty, th, tw]转化成预测框的坐标[x1, y1, x2, y2]\n",
    "def get_yolo_box_xxyy(pred, anchors, num_classes, downsample):\n",
    "    \"\"\"\n",
    "    pred是网络输出特征图转化成的numpy.ndarray\n",
    "    anchors 是一个list。表示锚框的大小，\n",
    "                例如 anchors = [116, 90, 156, 198, 373, 326]，表示有三个锚框，\n",
    "                第一个锚框大小[w, h]是[116, 90]，第二个锚框大小是[156, 198]，第三个锚框大小是[373, 326]\n",
    "    \"\"\"\n",
    "    batchsize = pred.shape[0]\n",
    "    num_rows = pred.shape[-2]\n",
    "    num_cols = pred.shape[-1]\n",
    "\n",
    "    input_h = num_rows * downsample\n",
    "    input_w = num_cols * downsample\n",
    "\n",
    "    num_anchors = len(anchors) // 2\n",
    "\n",
    "    # pred的形状是[N, C, H, W]，其中C = NUM_ANCHORS * (5 + NUM_CLASSES)\n",
    "    # 对pred进行reshape\n",
    "    pred = pred.reshape([-1, num_anchors, 5+num_classes, num_rows, num_cols])\n",
    "    pred_location = pred[:, :, 0:4, :, :]\n",
    "    pred_location = np.transpose(pred_location, (0,3,4,1,2))\n",
    "    anchors_this = []\n",
    "    for ind in range(num_anchors):\n",
    "        anchors_this.append([anchors[ind*2], anchors[ind*2+1]])\n",
    "    anchors_this = np.array(anchors_this).astype('float32')\n",
    "    \n",
    "    # 最终输出数据保存在pred_box中，其形状是[N, H, W, NUM_ANCHORS, 4]，\n",
    "    # 其中最后一个维度4代表位置的4个坐标\n",
    "    pred_box = np.zeros(pred_location.shape)\n",
    "    for n in range(batchsize):\n",
    "        for i in range(num_rows):\n",
    "            for j in range(num_cols):\n",
    "                for k in range(num_anchors):\n",
    "                    pred_box[n, i, j, k, 0] = j\n",
    "                    pred_box[n, i, j, k, 1] = i\n",
    "                    pred_box[n, i, j, k, 2] = anchors_this[k][0]\n",
    "                    pred_box[n, i, j, k, 3] = anchors_this[k][1]\n",
    "\n",
    "    # 这里使用相对坐标，pred_box的输出元素数值在0.~1.0之间\n",
    "    pred_box[:, :, :, :, 0] = (sigmoid(pred_location[:, :, :, :, 0]) + pred_box[:, :, :, :, 0]) / num_cols\n",
    "    pred_box[:, :, :, :, 1] = (sigmoid(pred_location[:, :, :, :, 1]) + pred_box[:, :, :, :, 1]) / num_rows\n",
    "    pred_box[:, :, :, :, 2] = np.exp(pred_location[:, :, :, :, 2]) * pred_box[:, :, :, :, 2] / input_w\n",
    "    pred_box[:, :, :, :, 3] = np.exp(pred_location[:, :, :, :, 3]) * pred_box[:, :, :, :, 3] / input_h\n",
    "\n",
    "    # 将坐标从xywh转化成xyxy\n",
    "    pred_box[:, :, :, :, 0] = pred_box[:, :, :, :, 0] - pred_box[:, :, :, :, 2] / 2.\n",
    "    pred_box[:, :, :, :, 1] = pred_box[:, :, :, :, 1] - pred_box[:, :, :, :, 3] / 2.\n",
    "    pred_box[:, :, :, :, 2] = pred_box[:, :, :, :, 0] + pred_box[:, :, :, :, 2]\n",
    "    pred_box[:, :, :, :, 3] = pred_box[:, :, :, :, 1] + pred_box[:, :, :, :, 3]\n",
    "\n",
    "    pred_box = np.clip(pred_box, 0., 1.0)\n",
    "\n",
    "    return pred_box\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过调用上面定义的`get_yolo_box_xxyy`函数，可以从$P0$计算出预测框坐标来，具体程序如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 20, 20, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "NUM_ANCHORS = 3\n",
    "NUM_CLASSES = 7\n",
    "num_filters=NUM_ANCHORS * (NUM_CLASSES + 5)\n",
    "\n",
    "backbone = DarkNet53_conv_body()\n",
    "detection = YoloDetectionBlock(ch_in=1024, ch_out=512)\n",
    "conv2d_pred = paddle.nn.Conv2D(in_channels=1024, out_channels=num_filters,  kernel_size=1)\n",
    "\n",
    "x = np.random.randn(1, 3, 640, 640).astype('float32')\n",
    "x = paddle.to_tensor(x)\n",
    "C0, C1, C2 = backbone(x)\n",
    "route, tip = detection(C0)\n",
    "P0 = conv2d_pred(tip)\n",
    "\n",
    "reshaped_p0 = paddle.reshape(P0, [-1, NUM_ANCHORS, NUM_CLASSES + 5, P0.shape[2], P0.shape[3]])\n",
    "pred_objectness = reshaped_p0[:, :, 4, :, :]\n",
    "pred_objectness_probability = F.sigmoid(pred_objectness)\n",
    "\n",
    "pred_location = reshaped_p0[:, :, 0:4, :, :]\n",
    "\n",
    "# anchors包含了预先设定好的锚框尺寸\n",
    "anchors = [116, 90, 156, 198, 373, 326]\n",
    "# downsample是特征图P0的步幅\n",
    "pred_boxes = get_yolo_box_xxyy(P0.numpy(), anchors, num_classes=7, downsample=32) # 由输出特征图P0计算预测框位置坐标\n",
    "print(pred_boxes.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面程序计算出来的pred_boxes的形状是$[N, H, W, num\\_anchors, 4]$，坐标格式是$[x_1, y_1, x_2, y_2]$，数值在0~1之间，表示相对坐标。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计算物体属于每个类别概率\n",
    "\n",
    "$P0[t, 5:12, i, j]$与输入的第$t$张图片上小方块区域$(i, j)$第1个预测框包含物体的类别对应，$P0[t, 17:24, i, j]$与第2个预测框的类别对应，...，使用下面的程序可以从$P0$中取出那些跟预测框类别相关的预测值。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 7, 20, 20]\n"
     ]
    }
   ],
   "source": [
    "NUM_ANCHORS = 3\n",
    "NUM_CLASSES = 7\n",
    "num_filters=NUM_ANCHORS * (NUM_CLASSES + 5)\n",
    "\n",
    "backbone = DarkNet53_conv_body()\n",
    "detection = YoloDetectionBlock(ch_in=1024, ch_out=512)\n",
    "conv2d_pred = paddle.nn.Conv2D(in_channels=1024, out_channels=num_filters,  kernel_size=1)\n",
    "\n",
    "x = np.random.randn(1, 3, 640, 640).astype('float32')\n",
    "x = paddle.to_tensor(x)\n",
    "C0, C1, C2 = backbone(x)\n",
    "route, tip = detection(C0)\n",
    "P0 = conv2d_pred(tip)\n",
    "\n",
    "reshaped_p0 = paddle.reshape(P0, [-1, NUM_ANCHORS, NUM_CLASSES + 5, P0.shape[2], P0.shape[3]])\n",
    "# 取出与objectness相关的预测值\n",
    "pred_objectness = reshaped_p0[:, :, 4, :, :]\n",
    "pred_objectness_probability = F.sigmoid(pred_objectness)\n",
    "# 取出与位置相关的预测值\n",
    "pred_location = reshaped_p0[:, :, 0:4, :, :]\n",
    "# 取出与类别相关的预测值\n",
    "pred_classification = reshaped_p0[:, :, 5:5+NUM_CLASSES, :, :]\n",
    "pred_classification_probability = F.sigmoid(pred_classification)\n",
    "print(pred_classification.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的程序通过$P0$计算出了预测框包含的物体所属类别的概率，`pred_classification_probability`的形状是$[1, 3, 7, 20, 20]$，数值在0~1之间。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 损失函数  \n",
    "\n",
    "上面从概念上将输出特征图上的像素点与预测框关联起来了，那么要对神经网络进行求解，还必须从数学上将网络输出和预测框关联起来，也就是要建立起损失函数跟网络输出之间的关系。下面讨论如何建立起YOLOv3的损失函数。\n",
    "\n",
    "对于每个预测框，YOLOv3模型会建立三种类型的损失函数：\n",
    "\n",
    "- 表征是否包含目标物体的损失函数，通过pred_objectness和label_objectness计算。\n",
    "\n",
    "        loss_obj = paddle.nn.fucntional.binary_cross_entropy_with_logits(pred_objectness, label_objectness)\n",
    "\n",
    "- 表征物体位置的损失函数，通过pred_location和label_location计算。\n",
    "\n",
    "        pred_location_x = pred_location[:, :, 0, :, :]\n",
    "        pred_location_y = pred_location[:, :, 1, :, :]\n",
    "        pred_location_w = pred_location[:, :, 2, :, :]\n",
    "        pred_location_h = pred_location[:, :, 3, :, :]\n",
    "        loss_location_x = paddle.nn.fucntional.binary_cross_entropy_with_logits(pred_location_x, label_location_x)\n",
    "        loss_location_y = paddle.nn.fucntional.binary_cross_entropy_with_logits(pred_location_y, label_location_y)\n",
    "        loss_location_w = paddle.abs(pred_location_w - label_location_w)\n",
    "        loss_location_h = paddle.abs(pred_location_h - label_location_h)\n",
    "        loss_location = loss_location_x + loss_location_y + loss_location_w + loss_location_h\n",
    "\n",
    "- 表征物体类别的损失函数，通过pred_classification和label_classification计算。\n",
    "\n",
    "        loss_obj = paddle.nn.fucntional.binary_cross_entropy_with_logits(pred_classification, label_classification)\n",
    "\n",
    "我们已经知道怎么计算这些预测值和标签了，但是遗留了一个小问题，就是没有标注出哪些锚框的objectness为-1。为了完成这一步，我们需要计算出所有预测框跟真实框之间的IoU，然后把那些IoU大于阈值的真实框挑选出来。实现代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 挑选出跟真实框IoU大于阈值的预测框\n",
    "def get_iou_above_thresh_inds(pred_box, gt_boxes, iou_threshold):\n",
    "    batchsize = pred_box.shape[0]\n",
    "    num_rows = pred_box.shape[1]\n",
    "    num_cols = pred_box.shape[2]\n",
    "    num_anchors = pred_box.shape[3]\n",
    "    ret_inds = np.zeros([batchsize, num_rows, num_cols, num_anchors])\n",
    "    for i in range(batchsize):\n",
    "        pred_box_i = pred_box[i]\n",
    "        gt_boxes_i = gt_boxes[i]\n",
    "        for k in range(len(gt_boxes_i)): #gt in gt_boxes_i:\n",
    "            gt = gt_boxes_i[k]\n",
    "            gtx_min = gt[0] - gt[2] / 2.\n",
    "            gty_min = gt[1] - gt[3] / 2.\n",
    "            gtx_max = gt[0] + gt[2] / 2.\n",
    "            gty_max = gt[1] + gt[3] / 2.\n",
    "            if (gtx_max - gtx_min < 1e-3) or (gty_max - gty_min < 1e-3):\n",
    "                continue\n",
    "            x1 = np.maximum(pred_box_i[:, :, :, 0], gtx_min)\n",
    "            y1 = np.maximum(pred_box_i[:, :, :, 1], gty_min)\n",
    "            x2 = np.minimum(pred_box_i[:, :, :, 2], gtx_max)\n",
    "            y2 = np.minimum(pred_box_i[:, :, :, 3], gty_max)\n",
    "            intersection = np.maximum(x2 - x1, 0.) * np.maximum(y2 - y1, 0.)\n",
    "            s1 = (gty_max - gty_min) * (gtx_max - gtx_min)\n",
    "            s2 = (pred_box_i[:, :, :, 2] - pred_box_i[:, :, :, 0]) * (pred_box_i[:, :, :, 3] - pred_box_i[:, :, :, 1])\n",
    "            union = s2 + s1 - intersection\n",
    "            iou = intersection / union\n",
    "            above_inds = np.where(iou > iou_threshold)\n",
    "            ret_inds[i][above_inds] = 1\n",
    "    ret_inds = np.transpose(ret_inds, (0,3,1,2))\n",
    "    return ret_inds.astype('bool')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的函数可以得到哪些锚框的objectness需要被标注为-1，通过下面的程序，对label_objectness进行处理，将IoU大于阈值，但又不是正样本的锚框标注为-1。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def label_objectness_ignore(label_objectness, iou_above_thresh_indices):\n",
    "    # 注意：这里不能简单的使用 label_objectness[iou_above_thresh_indices] = -1，\n",
    "    #         这样可能会造成label_objectness为1的点被设置为-1了\n",
    "    #         只有将那些被标注为0，且与真实框IoU超过阈值的预测框才被标注为-1\n",
    "    negative_indices = (label_objectness < 0.5)\n",
    "    ignore_indices = negative_indices * iou_above_thresh_indices\n",
    "    label_objectness[ignore_indices] = -1\n",
    "    return label_objectness"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面通过调用这两个函数，实现如何将部分预测框的label_objectness设置为-1。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/nn/layer/norm.py:636: UserWarning: When training, we now always track global mean and variance.\n",
      "  \"When training, we now always track global mean and variance.\")\n"
     ]
    }
   ],
   "source": [
    "# 读取数据\n",
    "reader = paddle.io.DataLoader(train_dataset, batch_size=2, shuffle=True, num_workers=1, drop_last=True)\n",
    "img, gt_boxes, gt_labels, im_shape = next(reader())\n",
    "img, gt_boxes, gt_labels, im_shape = img.numpy(), gt_boxes.numpy(), gt_labels.numpy(), im_shape.numpy()\n",
    "# 计算出锚框对应的标签\n",
    "label_objectness, label_location, label_classification, scale_location = get_objectness_label(img,\n",
    "                                                                                              gt_boxes, gt_labels, \n",
    "                                                                                              iou_threshold = 0.7,\n",
    "                                                                                              anchors = [116, 90, 156, 198, 373, 326],\n",
    "                                                                                              num_classes=7, downsample=32)\n",
    "                                               \n",
    "NUM_ANCHORS = 3\n",
    "NUM_CLASSES = 7\n",
    "num_filters=NUM_ANCHORS * (NUM_CLASSES + 5)\n",
    "\n",
    "backbone = DarkNet53_conv_body()\n",
    "detection = YoloDetectionBlock(ch_in=1024, ch_out=512)\n",
    "conv2d_pred = paddle.nn.Conv2D(in_channels=1024, out_channels=num_filters,  kernel_size=1)\n",
    "\n",
    "x = paddle.to_tensor(img)\n",
    "C0, C1, C2 = backbone(x)\n",
    "route, tip = detection(C0)\n",
    "P0 = conv2d_pred(tip)\n",
    "\n",
    "# anchors包含了预先设定好的锚框尺寸\n",
    "anchors = [116, 90, 156, 198, 373, 326]\n",
    "# downsample是特征图P0的步幅\n",
    "pred_boxes = get_yolo_box_xxyy(P0.numpy(), anchors, num_classes=7, downsample=32)\n",
    "iou_above_thresh_indices = get_iou_above_thresh_inds(pred_boxes, gt_boxes, iou_threshold=0.7)\n",
    "label_objectness = label_objectness_ignore(label_objectness, iou_above_thresh_indices)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用这种方式，就可以将那些没有被标注为正样本，但又与真实框IoU比较大的样本objectness标签设置为-1了，不计算其对任何一种损失函数的贡献。计算总的损失函数的代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_loss(output, label_objectness, label_location, label_classification, scales, num_anchors=3, num_classes=7):\n",
    "    # 将output从[N, C, H, W]变形为[N, NUM_ANCHORS, NUM_CLASSES + 5, H, W]\n",
    "    reshaped_output = paddle.reshape(output, [-1, num_anchors, num_classes + 5, output.shape[2], output.shape[3]])\n",
    "\n",
    "    # 从output中取出跟objectness相关的预测值\n",
    "    pred_objectness = reshaped_output[:, :, 4, :, :]\n",
    "    loss_objectness = F.binary_cross_entropy_with_logits(pred_objectness, label_objectness, reduction=\"none\")\n",
    "\n",
    "    # pos_samples 只有在正样本的地方取值为1.，其它地方取值全为0.\n",
    "    pos_objectness = label_objectness > 0\n",
    "    pos_samples = paddle.cast(pos_objectness, 'float32')\n",
    "    pos_samples.stop_gradient=True\n",
    "\n",
    "    # 从output中取出所有跟位置相关的预测值\n",
    "    tx = reshaped_output[:, :, 0, :, :]\n",
    "    ty = reshaped_output[:, :, 1, :, :]\n",
    "    tw = reshaped_output[:, :, 2, :, :]\n",
    "    th = reshaped_output[:, :, 3, :, :]\n",
    "\n",
    "    # 从label_location中取出各个位置坐标的标签\n",
    "    dx_label = label_location[:, :, 0, :, :]\n",
    "    dy_label = label_location[:, :, 1, :, :]\n",
    "    tw_label = label_location[:, :, 2, :, :]\n",
    "    th_label = label_location[:, :, 3, :, :]\n",
    "\n",
    "    # 构建损失函数\n",
    "    loss_location_x = F.binary_cross_entropy_with_logits(tx, dx_label, reduction=\"none\")\n",
    "    loss_location_y = F.binary_cross_entropy_with_logits(ty, dy_label, reduction=\"none\")\n",
    "    loss_location_w = paddle.abs(tw - tw_label)\n",
    "    loss_location_h = paddle.abs(th - th_label)\n",
    "\n",
    "    # 计算总的位置损失函数\n",
    "    loss_location = loss_location_x + loss_location_y + loss_location_h + loss_location_w\n",
    "\n",
    "    # 乘以scales\n",
    "    loss_location = loss_location * scales\n",
    "    # 只计算正样本的位置损失函数\n",
    "    loss_location = loss_location * pos_samples\n",
    "\n",
    "    # 从output取出所有跟物体类别相关的像素点\n",
    "    pred_classification = reshaped_output[:, :, 5:5+num_classes, :, :]\n",
    "\n",
    "    # 计算分类相关的损失函数\n",
    "    loss_classification = F.binary_cross_entropy_with_logits(pred_classification, label_classification, reduction=\"none\")\n",
    "   \n",
    "    # 将第2维求和\n",
    "    loss_classification = paddle.sum(loss_classification, axis=2)\n",
    "    # 只计算objectness为正的样本的分类损失函数\n",
    "    loss_classification = loss_classification * pos_samples\n",
    "    total_loss = loss_objectness + loss_location + loss_classification\n",
    "    # 对所有预测框的loss进行求和\n",
    "    total_loss = paddle.sum(total_loss, axis=[1,2,3])\n",
    "    # 对所有样本求平均\n",
    "    total_loss = paddle.mean(total_loss)\n",
    "\n",
    "    return total_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[894.4463]\n"
     ]
    }
   ],
   "source": [
    "from paddle.nn import Conv2D\n",
    "\n",
    "# 计算出锚框对应的标签\n",
    "label_objectness, label_location, label_classification, scale_location = get_objectness_label(img,\n",
    "                                                                                              gt_boxes, gt_labels, \n",
    "                                                                                              iou_threshold = 0.7,\n",
    "                                                                                              anchors = [116, 90, 156, 198, 373, 326],\n",
    "                                                                                              num_classes=7, downsample=32)                                                           \n",
    "\n",
    "NUM_ANCHORS = 3\n",
    "NUM_CLASSES = 7\n",
    "num_filters=NUM_ANCHORS * (NUM_CLASSES + 5)\n",
    "\n",
    "backbone = DarkNet53_conv_body()\n",
    "detection = YoloDetectionBlock(ch_in=1024, ch_out=512)\n",
    "conv2d_pred = Conv2D(in_channels=1024, out_channels=num_filters,  kernel_size=1)\n",
    "\n",
    "x = paddle.to_tensor(img)\n",
    "C0, C1, C2 = backbone(x)\n",
    "route, tip = detection(C0)\n",
    "P0 = conv2d_pred(tip)\n",
    "# anchors包含了预先设定好的锚框尺寸\n",
    "anchors = [116, 90, 156, 198, 373, 326]\n",
    "# downsample是特征图P0的步幅\n",
    "pred_boxes = get_yolo_box_xxyy(P0.numpy(), anchors, num_classes=7, downsample=32)\n",
    "iou_above_thresh_indices = get_iou_above_thresh_inds(pred_boxes, gt_boxes, iou_threshold=0.7)\n",
    "label_objectness = label_objectness_ignore(label_objectness, iou_above_thresh_indices)\n",
    "\n",
    "label_objectness = paddle.to_tensor(label_objectness)\n",
    "label_location = paddle.to_tensor(label_location)\n",
    "label_classification = paddle.to_tensor(label_classification)\n",
    "scales = paddle.to_tensor(scale_location)\n",
    "label_objectness.stop_gradient=True\n",
    "label_location.stop_gradient=True\n",
    "label_classification.stop_gradient=True\n",
    "scales.stop_gradient=True\n",
    "\n",
    "total_loss = get_loss(P0, label_objectness, label_location, label_classification, scales,\n",
    "                          num_anchors=NUM_ANCHORS, num_classes=NUM_CLASSES)\n",
    "total_loss_data = total_loss.numpy()\n",
    "print(total_loss_data)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的程序计算出了总的损失函数，看到这里，读者已经了解到了YOLOv3算法的大部分内容，包括如何生成锚框、给锚框打上标签、通过卷积神经网络提取特征、将输出特征图跟预测框相关联、建立起损失函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多尺度检测\n",
    "\n",
    "目前我们计算损失函数是在特征图P0的基础上进行的，它的步幅stride=32。特征图的尺寸比较小，像素点数目比较少，每个像素点的感受野很大，具有非常丰富的高层级语义信息，可能比较容易检测到较大的目标。为了能够检测到尺寸较小的那些目标，需要在尺寸较大的特征图上面建立预测输出。如果我们在C2或者C1这种层级的特征图上直接产生预测输出，可能面临新的问题，它们没有经过充分的特征提取，像素点包含的语义信息不够丰富，有可能难以提取到有效的特征模式。在目标检测中，解决这一问题的方式是，将高层级的特征图尺寸放大之后跟低层级的特征图进行融合，得到的新特征图既能包含丰富的语义信息，又具有较多的像素点，能够描述更加精细的结构。\n",
    "\n",
    "具体的网络实现方式如 **图19** 所示：\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/b6d3b425644342e48bd0a50ebde90d882fd10717e0e44a53a44e98225bbb6df8\" width = \"800\"></center>\n",
    "<center><br>图19：生成多层级的输出特征图P0、P1、P2 </br></center>\n",
    "<br></br>\n",
    "\n",
    "YOLOv3在每个区域的中心位置产生3个锚框，在3个层级的特征图上产生锚框的大小分别为P2 [(10×13),(16×30),(33×23)]，P1 [(30×61),(62×45),(59× 119)]，P0[(116 × 90), (156 × 198), (373 × 326]。越往后的特征图上用到的锚框尺寸也越大，能捕捉到大尺寸目标的信息；越往前的特征图上锚框尺寸越小，能捕捉到小尺寸目标的信息。\n",
    "\n",
    "因为有多尺度的检测，所以需要对上面的代码进行较大的修改，而且实现过程也略显繁琐，所以推荐大家直接使用飞桨 [paddle.vision.ops.yolo_loss](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc1/api/paddle/vision/ops/yolo_loss_cn.html) API，关键参数说明如下：\n",
    "\n",
    "> paddle.vision.ops.yolo_loss(x, gt_box, gt_label, anchors, anchor_mask, class_num, ignore_thresh, downsample_ratio, gt_score=None, use_label_smooth=True, name=None, scale_x_y=1.0)\n",
    "\n",
    "- x: 输出特征图。\n",
    "- gt_box: 真实框。\n",
    "- gt_label: 真实框标签。\n",
    "- ignore_thresh，预测框与真实框IoU阈值超过ignore_thresh时，不作为负样本，YOLOv3模型里设置为0.7。\n",
    "- downsample_ratio，特征图P0的下采样比例，使用Darknet53骨干网络时为32。\n",
    "- gt_score，真实框的置信度，在使用了mixup技巧时用到。\n",
    "- use_label_smooth，一种训练技巧，如不使用，设置为False。\n",
    "- name，该层的名字，比如'yolov3_loss'，默认值为None，一般无需设置。\n",
    "\n",
    "对于使用了多层级特征图产生预测框的方法，其具体实现代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义上采样模块\n",
    "class Upsample(paddle.nn.Layer):\n",
    "    def __init__(self, scale=2):\n",
    "        super(Upsample,self).__init__()\n",
    "        self.scale = scale\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        # get dynamic upsample output shape\n",
    "        shape_nchw = paddle.shape(inputs)\n",
    "        shape_hw = paddle.slice(shape_nchw, axes=[0], starts=[2], ends=[4])\n",
    "        shape_hw.stop_gradient = True\n",
    "        in_shape = paddle.cast(shape_hw, dtype='int32')\n",
    "        out_shape = in_shape * self.scale\n",
    "        out_shape.stop_gradient = True\n",
    "\n",
    "        # reisze by actual_shape\n",
    "        out = paddle.nn.functional.interpolate(\n",
    "            x=inputs, scale_factor=self.scale, mode=\"NEAREST\")\n",
    "        return out\n",
    "\n",
    "\n",
    "class YOLOv3(paddle.nn.Layer):\n",
    "    def __init__(self, num_classes=7):\n",
    "        super(YOLOv3,self).__init__()\n",
    "\n",
    "        self.num_classes = num_classes\n",
    "        # 提取图像特征的骨干代码\n",
    "        self.block = DarkNet53_conv_body()\n",
    "        self.block_outputs = []\n",
    "        self.yolo_blocks = []\n",
    "        self.route_blocks_2 = []\n",
    "        # 生成3个层级的特征图P0, P1, P2\n",
    "        for i in range(3):\n",
    "            # 添加从ci生成ri和ti的模块\n",
    "            yolo_block = self.add_sublayer(\n",
    "                \"yolo_detecton_block_%d\" % (i),\n",
    "                YoloDetectionBlock(\n",
    "                                   ch_in=512//(2**i)*2 if i==0 else 512//(2**i)*2 + 512//(2**i),\n",
    "                                   ch_out = 512//(2**i)))\n",
    "            self.yolo_blocks.append(yolo_block)\n",
    "\n",
    "            num_filters = 3 * (self.num_classes + 5)\n",
    "\n",
    "            # 添加从ti生成pi的模块，这是一个Conv2D操作，输出通道数为3 * (num_classes + 5)\n",
    "            block_out = self.add_sublayer(\n",
    "                \"block_out_%d\" % (i),\n",
    "                paddle.nn.Conv2D(in_channels=512//(2**i)*2,\n",
    "                       out_channels=num_filters,\n",
    "                       kernel_size=1,\n",
    "                       stride=1,\n",
    "                       padding=0,\n",
    "                       weight_attr=paddle.ParamAttr(\n",
    "                           initializer=paddle.nn.initializer.Normal(0., 0.02)),\n",
    "                       bias_attr=paddle.ParamAttr(\n",
    "                           initializer=paddle.nn.initializer.Constant(0.0),\n",
    "                           regularizer=paddle.regularizer.L2Decay(0.))))\n",
    "            self.block_outputs.append(block_out)\n",
    "            if i < 2:\n",
    "                # 对ri进行卷积\n",
    "                route = self.add_sublayer(\"route2_%d\"%i,\n",
    "                                          ConvBNLayer(ch_in=512//(2**i),\n",
    "                                                      ch_out=256//(2**i),\n",
    "                                                      kernel_size=1,\n",
    "                                                      stride=1,\n",
    "                                                      padding=0))\n",
    "                self.route_blocks_2.append(route)\n",
    "            # 将ri放大以便跟c_{i+1}保持同样的尺寸\n",
    "            self.upsample = Upsample()\n",
    "    def forward(self, inputs):\n",
    "        outputs = []\n",
    "        blocks = self.block(inputs)\n",
    "        for i, block in enumerate(blocks):\n",
    "            if i > 0:\n",
    "                # 将r_{i-1}经过卷积和上采样之后得到特征图，与这一级的ci进行拼接\n",
    "                block = paddle.concat([route, block], axis=1)\n",
    "            # 从ci生成ti和ri\n",
    "            route, tip = self.yolo_blocks[i](block)\n",
    "            # 从ti生成pi\n",
    "            block_out = self.block_outputs[i](tip)\n",
    "            # 将pi放入列表\n",
    "            outputs.append(block_out)\n",
    "\n",
    "            if i < 2:\n",
    "                # 对ri进行卷积调整通道数\n",
    "                route = self.route_blocks_2[i](route)\n",
    "                # 对ri进行放大，使其尺寸和c_{i+1}保持一致\n",
    "                route = self.upsample(route)\n",
    "\n",
    "        return outputs\n",
    "\n",
    "    def get_loss(self, outputs, gtbox, gtlabel, gtscore=None,\n",
    "                 anchors = [10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326],\n",
    "                 anchor_masks = [[6, 7, 8], [3, 4, 5], [0, 1, 2]],\n",
    "                 ignore_thresh=0.7,\n",
    "                 use_label_smooth=False):\n",
    "        \"\"\"\n",
    "        使用paddle.vision.ops.yolo_loss，直接计算损失函数，过程更简洁，速度也更快\n",
    "        \"\"\"\n",
    "        self.losses = []\n",
    "        downsample = 32\n",
    "        for i, out in enumerate(outputs): # 对三个层级分别求损失函数\n",
    "            anchor_mask_i = anchor_masks[i]\n",
    "            loss = paddle.vision.ops.yolo_loss(\n",
    "                    x=out,  # out是P0, P1, P2中的一个\n",
    "                    gt_box=gtbox,  # 真实框坐标\n",
    "                    gt_label=gtlabel,  # 真实框类别\n",
    "                    gt_score=gtscore,  # 真实框得分，使用mixup训练技巧时需要，不使用该技巧时直接设置为1，形状与gtlabel相同\n",
    "                    anchors=anchors,   # 锚框尺寸，包含[w0, h0, w1, h1, ..., w8, h8]共9个锚框的尺寸\n",
    "                    anchor_mask=anchor_mask_i, # 筛选锚框的mask，例如anchor_mask_i=[3, 4, 5]，将anchors中第3、4、5个锚框挑选出来给该层级使用\n",
    "                    class_num=self.num_classes, # 分类类别数\n",
    "                    ignore_thresh=ignore_thresh, # 当预测框与真实框IoU > ignore_thresh，标注objectness = -1\n",
    "                    downsample_ratio=downsample, # 特征图相对于原图缩小的倍数，例如P0是32， P1是16，P2是8\n",
    "                    use_label_smooth=False)      # 使用label_smooth训练技巧时会用到，这里没用此技巧，直接设置为False\n",
    "            self.losses.append(paddle.mean(loss))  #mean对每张图片求和\n",
    "            downsample = downsample // 2 # 下一级特征图的缩放倍数会减半\n",
    "        return sum(self.losses) # 对每个层级求和"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 开启端到端训练\n",
    "\n",
    "训练过程如 **图20** 所示，输入图片经过特征提取得到三个层级的输出特征图P0(stride=32)、P1(stride=16)和P2(stride=8)，相应的分别使用不同大小的小方块区域去生成对应的锚框和预测框，并对这些锚框进行标注。\n",
    "\n",
    "- P0层级特征图，对应着使用$32\\times32$大小的小方块，在每个区域中心生成大小分别为$[116, 90]$, $[156, 198]$, $[373, 326]$的三种锚框。\n",
    "\n",
    "- P1层级特征图，对应着使用$16\\times16$大小的小方块，在每个区域中心生成大小分别为$[30, 61]$, $[62, 45]$, $[59, 119]$的三种锚框。\n",
    "\n",
    "- P2层级特征图，对应着使用$8\\times8$大小的小方块，在每个区域中心生成大小分别为$[10, 13]$, $[16, 30]$, $[33, 23]$的三种锚框。\n",
    "\n",
    "将三个层级的特征图与对应锚框之间的标签关联起来，并建立损失函数，总的损失函数等于三个层级的损失函数相加。通过极小化损失函数，可以开启端到端的训练过程。\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/736da9cd3a4f4a1c98187a6cdf1a0334af73470b6d7c4b2fbaa9660d4bd20621\" width = \"600\"></center>\n",
    "<center><br>图20：端到端训练流程 </br></center>\n",
    "<br></br>\n",
    "\n",
    "训练过程的具体实现代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "############# 这段代码在本地机器上运行请慎重，容易造成死机#######################\n",
    "\n",
    "import time\n",
    "import os\n",
    "import paddle\n",
    "\n",
    "ANCHORS = [10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326]\n",
    "\n",
    "ANCHOR_MASKS = [[6, 7, 8], [3, 4, 5], [0, 1, 2]]\n",
    "\n",
    "IGNORE_THRESH = .7\n",
    "NUM_CLASSES = 7\n",
    "\n",
    "def get_lr(base_lr = 0.0001, lr_decay = 0.1):\n",
    "    bd = [10000, 20000]\n",
    "    lr = [base_lr, base_lr * lr_decay, base_lr * lr_decay * lr_decay]\n",
    "    learning_rate = paddle.optimizer.lr.PiecewiseDecay(boundaries=bd, values=lr)\n",
    "    return learning_rate\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "\n",
    "    TRAINDIR = '/home/aistudio/work/insects/train'\n",
    "    TESTDIR = '/home/aistudio/work/insects/test'\n",
    "    VALIDDIR = '/home/aistudio/work/insects/val'\n",
    "    paddle.set_device(\"gpu:0\")\n",
    "    # 创建数据读取类\n",
    "    train_dataset = TrainDataset(TRAINDIR, mode='train')\n",
    "    valid_dataset = TrainDataset(VALIDDIR, mode='valid')\n",
    "    test_dataset = TrainDataset(VALIDDIR, mode='valid')\n",
    "    # 使用paddle.io.DataLoader创建数据读取器，并设置batchsize，进程数量num_workers等参数\n",
    "    train_loader = paddle.io.DataLoader(train_dataset, batch_size=10, shuffle=True, num_workers=0, drop_last=True, use_shared_memory=False)\n",
    "    valid_loader = paddle.io.DataLoader(valid_dataset, batch_size=10, shuffle=False, num_workers=0, drop_last=False, use_shared_memory=False)\n",
    "    model = YOLOv3(num_classes = NUM_CLASSES)  #创建模型\n",
    "    learning_rate = get_lr()\n",
    "    opt = paddle.optimizer.Momentum(\n",
    "                 learning_rate=learning_rate,\n",
    "                 momentum=0.9,\n",
    "                 weight_decay=paddle.regularizer.L2Decay(0.0005),\n",
    "                 parameters=model.parameters())  #创建优化器\n",
    "    # opt = paddle.optimizer.Adam(learning_rate=learning_rate, weight_decay=paddle.regularizer.L2Decay(0.0005), parameters=model.parameters())\n",
    "\n",
    "    MAX_EPOCH = 200\n",
    "    for epoch in range(MAX_EPOCH):\n",
    "        for i, data in enumerate(train_loader()):\n",
    "            img, gt_boxes, gt_labels, img_scale = data\n",
    "            gt_scores = np.ones(gt_labels.shape).astype('float32')\n",
    "            gt_scores = paddle.to_tensor(gt_scores)\n",
    "            img = paddle.to_tensor(img)\n",
    "            gt_boxes = paddle.to_tensor(gt_boxes)\n",
    "            gt_labels = paddle.to_tensor(gt_labels)\n",
    "            outputs = model(img)  #前向传播，输出[P0, P1, P2]\n",
    "            loss = model.get_loss(outputs, gt_boxes, gt_labels, gtscore=gt_scores,\n",
    "                                  anchors = ANCHORS,\n",
    "                                  anchor_masks = ANCHOR_MASKS,\n",
    "                                  ignore_thresh=IGNORE_THRESH,\n",
    "                                  use_label_smooth=False)        # 计算损失函数\n",
    "\n",
    "            loss.backward()    # 反向传播计算梯度\n",
    "            opt.step()  # 更新参数\n",
    "            opt.clear_grad()\n",
    "            if i % 10 == 0:\n",
    "                timestring = time.strftime(\"%Y-%m-%d %H:%M:%S\",time.localtime(time.time()))\n",
    "                print('{}[TRAIN]epoch {}, iter {}, output loss: {}'.format(timestring, epoch, i, loss.numpy()))\n",
    "\n",
    "        # save params of model\n",
    "        if (epoch % 5 == 0) or (epoch == MAX_EPOCH -1):\n",
    "            paddle.save(model.state_dict(), 'yolo_epoch{}'.format(epoch))\n",
    "\n",
    "        # 每个epoch结束之后在验证集上进行测试\n",
    "        model.eval()\n",
    "        for i, data in enumerate(valid_loader()):\n",
    "            img, gt_boxes, gt_labels, img_scale = data\n",
    "            gt_scores = np.ones(gt_labels.shape).astype('float32')\n",
    "            gt_scores = paddle.to_tensor(gt_scores)\n",
    "            img = paddle.to_tensor(img)\n",
    "            gt_boxes = paddle.to_tensor(gt_boxes)\n",
    "            gt_labels = paddle.to_tensor(gt_labels)\n",
    "            outputs = model(img)\n",
    "            loss = model.get_loss(outputs, gt_boxes, gt_labels, gtscore=gt_scores,\n",
    "                                  anchors = ANCHORS,\n",
    "                                  anchor_masks = ANCHOR_MASKS,\n",
    "                                  ignore_thresh=IGNORE_THRESH,\n",
    "                                  use_label_smooth=False)\n",
    "            if i % 1 == 0:\n",
    "                timestring = time.strftime(\"%Y-%m-%d %H:%M:%S\",time.localtime(time.time()))\n",
    "                print('{}[VALID]epoch {}, iter {}, output loss: {}'.format(timestring, epoch, i, loss.numpy()))\n",
    "        model.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 预测\n",
    "\n",
    "预测过程流程 **图21** 如下所示：\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/15c140b1844d419cbe237b1a70f4099266aa168c05dc413f8e232f688050fa75\" width = \"400\"></center>\n",
    "<center><br>图21：预测流程 </br></center>\n",
    "<br></br>\n",
    "\n",
    "预测过程可以分为两步：\n",
    "\n",
    "1. 通过网络输出计算出预测框位置和所属类别的得分。 \n",
    "1. 使用非极大值抑制来消除重叠较大的预测框。\n",
    "\n",
    "\n",
    "对于第1步，前面我们已经讲过如何通过网络输出值计算pred_objectness_probability, pred_boxes以及pred_classification_probability，这里推荐大家直接使用[paddle.vision.ops.yolo_box](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc1/api/paddle/vision/ops/yolo_box_cn.html)，关键参数含义如下：\n",
    "\n",
    "> paddle.vision.ops.yolo_box(x, img_size, anchors, class_num, conf_thresh, downsample_ratio, clip_bbox=True, name=None, scale_x_y=1.0)\n",
    "\n",
    "- x，网络输出特征图，例如上面提到的P0或者P1、P2。\n",
    "- img_size，输入图片尺寸。\n",
    "- anchors，使用到的anchor的尺寸，如[10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326]\n",
    "- anchor_mask: 每个层级上使用的anchor的掩码，[[6, 7, 8], [3, 4, 5], [0, 1, 2]]\n",
    "- class_num，物体类别数。\n",
    "- conf_thresh, 置信度阈值，得分低于该阈值的预测框位置数值不用计算直接设置为0.0。\n",
    "- downsample_ratio, 特征图的下采样比例，例如P0是32，P1是16，P2是8。\n",
    "- name=None，名字，例如'yolo_box'，一般无需设置，默认值为None。\n",
    "   \n",
    "返回值包括两项，boxes和scores，其中boxes是所有预测框的坐标值，scores是所有预测框的得分。\n",
    "\n",
    "预测框得分的定义是所属类别的概率乘以其预测框是否包含目标物体的objectness概率，即\n",
    "\n",
    "$$score = P_{obj} \\cdot P_{classification}$$\n",
    "\n",
    "在上面定义的类YOLOv3下面添加函数，get_pred，通过调用`paddle.vision.ops.yolo_box`获得P0、P1、P2三个层级的特征图对应的预测框和得分，并将他们拼接在一块，即可得到所有的预测框及其属于各个类别的得分。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义YOLOv3模型\n",
    "class YOLOv3(paddle.nn.Layer):\n",
    "    def __init__(self, num_classes=7):\n",
    "        super(YOLOv3,self).__init__()\n",
    "\n",
    "        self.num_classes = num_classes\n",
    "        # 提取图像特征的骨干代码\n",
    "        self.block = DarkNet53_conv_body()\n",
    "        self.block_outputs = []\n",
    "        self.yolo_blocks = []\n",
    "        self.route_blocks_2 = []\n",
    "        # 生成3个层级的特征图P0, P1, P2\n",
    "        for i in range(3):\n",
    "            # 添加从ci生成ri和ti的模块\n",
    "            yolo_block = self.add_sublayer(\n",
    "                \"yolo_detecton_block_%d\" % (i),\n",
    "                YoloDetectionBlock(\n",
    "                                   ch_in=512//(2**i)*2 if i==0 else 512//(2**i)*2 + 512//(2**i),\n",
    "                                   ch_out = 512//(2**i)))\n",
    "            self.yolo_blocks.append(yolo_block)\n",
    "\n",
    "            num_filters = 3 * (self.num_classes + 5)\n",
    "\n",
    "            # 添加从ti生成pi的模块，这是一个Conv2D操作，输出通道数为3 * (num_classes + 5)\n",
    "            block_out = self.add_sublayer(\n",
    "                \"block_out_%d\" % (i),\n",
    "                paddle.nn.Conv2D(in_channels=512//(2**i)*2,\n",
    "                       out_channels=num_filters,\n",
    "                       kernel_size=1,\n",
    "                       stride=1,\n",
    "                       padding=0,\n",
    "                       weight_attr=paddle.ParamAttr(\n",
    "                           initializer=paddle.nn.initializer.Normal(0., 0.02)),\n",
    "                       bias_attr=paddle.ParamAttr(\n",
    "                           initializer=paddle.nn.initializer.Constant(0.0),\n",
    "                           regularizer=paddle.regularizer.L2Decay(0.))))\n",
    "            self.block_outputs.append(block_out)\n",
    "            if i < 2:\n",
    "                # 对ri进行卷积\n",
    "                route = self.add_sublayer(\"route2_%d\"%i,\n",
    "                                          ConvBNLayer(ch_in=512//(2**i),\n",
    "                                                      ch_out=256//(2**i),\n",
    "                                                      kernel_size=1,\n",
    "                                                      stride=1,\n",
    "                                                      padding=0))\n",
    "                self.route_blocks_2.append(route)\n",
    "            # 将ri放大以便跟c_{i+1}保持同样的尺寸\n",
    "            self.upsample = Upsample()\n",
    "    def forward(self, inputs):\n",
    "        outputs = []\n",
    "        blocks = self.block(inputs)\n",
    "        for i, block in enumerate(blocks):\n",
    "            if i > 0:\n",
    "                # 将r_{i-1}经过卷积和上采样之后得到特征图，与这一级的ci进行拼接\n",
    "                block = paddle.concat([route, block], axis=1)\n",
    "            # 从ci生成ti和ri\n",
    "            route, tip = self.yolo_blocks[i](block)\n",
    "            # 从ti生成pi\n",
    "            block_out = self.block_outputs[i](tip)\n",
    "            # 将pi放入列表\n",
    "            outputs.append(block_out)\n",
    "\n",
    "            if i < 2:\n",
    "                # 对ri进行卷积调整通道数\n",
    "                route = self.route_blocks_2[i](route)\n",
    "                # 对ri进行放大，使其尺寸和c_{i+1}保持一致\n",
    "                route = self.upsample(route)\n",
    "\n",
    "        return outputs\n",
    "\n",
    "    def get_loss(self, outputs, gtbox, gtlabel, gtscore=None,\n",
    "                 anchors = [10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326],\n",
    "                 anchor_masks = [[6, 7, 8], [3, 4, 5], [0, 1, 2]],\n",
    "                 ignore_thresh=0.7,\n",
    "                 use_label_smooth=False):\n",
    "        \"\"\"\n",
    "        使用paddle.vision.ops.yolo_loss，直接计算损失函数，过程更简洁，速度也更快\n",
    "        \"\"\"\n",
    "        self.losses = []\n",
    "        downsample = 32\n",
    "        for i, out in enumerate(outputs): # 对三个层级分别求损失函数\n",
    "            anchor_mask_i = anchor_masks[i]\n",
    "            loss = paddle.vision.ops.yolo_loss(\n",
    "                    x=out,  # out是P0, P1, P2中的一个\n",
    "                    gt_box=gtbox,  # 真实框坐标\n",
    "                    gt_label=gtlabel,  # 真实框类别\n",
    "                    gt_score=gtscore,  # 真实框得分，使用mixup训练技巧时需要，不使用该技巧时直接设置为1，形状与gtlabel相同\n",
    "                    anchors=anchors,   # 锚框尺寸，包含[w0, h0, w1, h1, ..., w8, h8]共9个锚框的尺寸\n",
    "                    anchor_mask=anchor_mask_i, # 筛选锚框的mask，例如anchor_mask_i=[3, 4, 5]，将anchors中第3、4、5个锚框挑选出来给该层级使用\n",
    "                    class_num=self.num_classes, # 分类类别数\n",
    "                    ignore_thresh=ignore_thresh, # 当预测框与真实框IoU > ignore_thresh，标注objectness = -1\n",
    "                    downsample_ratio=downsample, # 特征图相对于原图缩小的倍数，例如P0是32， P1是16，P2是8\n",
    "                    use_label_smooth=False)      # 使用label_smooth训练技巧时会用到，这里没用此技巧，直接设置为False\n",
    "            self.losses.append(paddle.mean(loss))  #mean对每张图片求和\n",
    "            downsample = downsample // 2 # 下一级特征图的缩放倍数会减半\n",
    "        return sum(self.losses) # 对每个层级求和\n",
    "\n",
    "    def get_pred(self,\n",
    "                 outputs,\n",
    "                 im_shape=None,\n",
    "                 anchors = [10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326],\n",
    "                 anchor_masks = [[6, 7, 8], [3, 4, 5], [0, 1, 2]],\n",
    "                 valid_thresh = 0.01):\n",
    "        downsample = 32\n",
    "        total_boxes = []\n",
    "        total_scores = []\n",
    "        for i, out in enumerate(outputs):\n",
    "            anchor_mask = anchor_masks[i]\n",
    "            anchors_this_level = []\n",
    "            for m in anchor_mask:\n",
    "                anchors_this_level.append(anchors[2 * m])\n",
    "                anchors_this_level.append(anchors[2 * m + 1])\n",
    "\n",
    "            boxes, scores = paddle.vision.ops.yolo_box(\n",
    "                   x=out,\n",
    "                   img_size=im_shape,\n",
    "                   anchors=anchors_this_level,\n",
    "                   class_num=self.num_classes,\n",
    "                   conf_thresh=valid_thresh,\n",
    "                   downsample_ratio=downsample,\n",
    "                   name=\"yolo_box\" + str(i))\n",
    "            total_boxes.append(boxes)\n",
    "            total_scores.append(\n",
    "                        paddle.transpose(\n",
    "                        scores, perm=[0, 2, 1]))\n",
    "            downsample = downsample // 2\n",
    "\n",
    "        yolo_boxes = paddle.concat(total_boxes, axis=1)\n",
    "        yolo_scores = paddle.concat(total_scores, axis=2)\n",
    "        return yolo_boxes, yolo_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第1步的计算结果会在每个小方块区域都会产生多个预测框，输出预测框中会有很多重合度比较大，需要消除重叠较大的冗余预测框。\n",
    "\n",
    "由于数据集中含有多个类别的物体，所以这里需要做多分类非极大值抑制，具体原理在上一节中已经介绍过了，实现代码如下面的`multiclass_nms`所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 非极大值抑制\n",
    "def nms(bboxes, scores, score_thresh, nms_thresh, pre_nms_topk, i=0, c=0):\n",
    "    \"\"\"\n",
    "    nms\n",
    "    \"\"\"\n",
    "    inds = np.argsort(scores)\n",
    "    inds = inds[::-1]\n",
    "    keep_inds = []\n",
    "    while(len(inds) > 0):\n",
    "        cur_ind = inds[0]\n",
    "        cur_score = scores[cur_ind]\n",
    "        # if score of the box is less than score_thresh, just drop it\n",
    "        if cur_score < score_thresh:\n",
    "            break\n",
    "\n",
    "        keep = True\n",
    "        for ind in keep_inds:\n",
    "            current_box = bboxes[cur_ind]\n",
    "            remain_box = bboxes[ind]\n",
    "            iou = box_iou_xyxy(current_box, remain_box)\n",
    "            if iou > nms_thresh:\n",
    "                keep = False\n",
    "                break\n",
    "        if i == 0 and c == 4 and cur_ind == 951:\n",
    "            print('suppressed, ', keep, i, c, cur_ind, ind, iou)\n",
    "        if keep:\n",
    "            keep_inds.append(cur_ind)\n",
    "        inds = inds[1:]\n",
    "\n",
    "    return np.array(keep_inds)\n",
    "\n",
    "# 多分类非极大值抑制\n",
    "def multiclass_nms(bboxes, scores, score_thresh=0.01, nms_thresh=0.45, pre_nms_topk=1000, pos_nms_topk=100):\n",
    "    \"\"\"\n",
    "    This is for multiclass_nms\n",
    "    \"\"\"\n",
    "    batch_size = bboxes.shape[0]\n",
    "    class_num = scores.shape[1]\n",
    "    rets = []\n",
    "    for i in range(batch_size):\n",
    "        bboxes_i = bboxes[i]\n",
    "        scores_i = scores[i]\n",
    "        ret = []\n",
    "        for c in range(class_num):\n",
    "            scores_i_c = scores_i[c]\n",
    "            keep_inds = nms(bboxes_i, scores_i_c, score_thresh, nms_thresh, pre_nms_topk, i=i, c=c)\n",
    "            if len(keep_inds) < 1:\n",
    "                continue\n",
    "            keep_bboxes = bboxes_i[keep_inds]\n",
    "            keep_scores = scores_i_c[keep_inds]\n",
    "            keep_results = np.zeros([keep_scores.shape[0], 6])\n",
    "            keep_results[:, 0] = c\n",
    "            keep_results[:, 1] = keep_scores[:]\n",
    "            keep_results[:, 2:6] = keep_bboxes[:, :]\n",
    "            ret.append(keep_results)\n",
    "        if len(ret) < 1:\n",
    "            rets.append(ret)\n",
    "            continue\n",
    "        ret_i = np.concatenate(ret, axis=0)\n",
    "        scores_i = ret_i[:, 1]\n",
    "        if len(scores_i) > pos_nms_topk:\n",
    "            inds = np.argsort(scores_i)[::-1]\n",
    "            inds = inds[:pos_nms_topk]\n",
    "            ret_i = ret_i[inds]\n",
    "\n",
    "        rets.append(ret_i)\n",
    "\n",
    "    return rets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面是完整的测试程序，在测试数据集上的输出结果将会被保存在pred_results.json文件中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算IoU，矩形框的坐标形式为xyxy，这个函数会被保存在box_utils.py文件中\n",
    "def box_iou_xyxy(box1, box2):\n",
    "    # 获取box1左上角和右下角的坐标\n",
    "    x1min, y1min, x1max, y1max = box1[0], box1[1], box1[2], box1[3]\n",
    "    # 计算box1的面积\n",
    "    s1 = (y1max - y1min + 1.) * (x1max - x1min + 1.)\n",
    "    # 获取box2左上角和右下角的坐标\n",
    "    x2min, y2min, x2max, y2max = box2[0], box2[1], box2[2], box2[3]\n",
    "    # 计算box2的面积\n",
    "    s2 = (y2max - y2min + 1.) * (x2max - x2min + 1.)\n",
    "    \n",
    "    # 计算相交矩形框的坐标\n",
    "    xmin = np.maximum(x1min, x2min)\n",
    "    ymin = np.maximum(y1min, y2min)\n",
    "    xmax = np.minimum(x1max, x2max)\n",
    "    ymax = np.minimum(y1max, y2max)\n",
    "    # 计算相交矩形行的高度、宽度、面积\n",
    "    inter_h = np.maximum(ymax - ymin + 1., 0.)\n",
    "    inter_w = np.maximum(xmax - xmin + 1., 0.)\n",
    "    intersection = inter_h * inter_w\n",
    "    # 计算相并面积\n",
    "    union = s1 + s2 - intersection\n",
    "    # 计算交并比\n",
    "    iou = intersection / union\n",
    "    return iou"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import os\n",
    "ANCHORS = [10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326]\n",
    "ANCHOR_MASKS = [[6, 7, 8], [3, 4, 5], [0, 1, 2]]\n",
    "VALID_THRESH = 0.01\n",
    "NMS_TOPK = 400\n",
    "NMS_POSK = 100\n",
    "NMS_THRESH = 0.45\n",
    "NUM_CLASSES = 7\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    TRAINDIR = '/home/aistudio/work/insects/train/images'\n",
    "    TESTDIR = '/home/aistudio/work/insects/test/images'\n",
    "    VALIDDIR = '/home/aistudio/work/insects/val'\n",
    "\n",
    "    model = YOLOv3(num_classes=NUM_CLASSES)\n",
    "    params_file_path = '/home/aistudio/yolo_epoch50.pdparams'\n",
    "    model_state_dict = paddle.load(params_file_path)\n",
    "    model.load_dict(model_state_dict)\n",
    "    model.eval()\n",
    "\n",
    "    total_results = []\n",
    "    test_loader = test_data_loader(TESTDIR, batch_size= 1, mode='test')\n",
    "    for i, data in enumerate(test_loader()):\n",
    "        img_name, img_data, img_scale_data = data\n",
    "        img = paddle.to_tensor(img_data)\n",
    "        img_scale = paddle.to_tensor(img_scale_data)\n",
    "\n",
    "        outputs = model.forward(img)\n",
    "        bboxes, scores = model.get_pred(outputs,\n",
    "                                 im_shape=img_scale,\n",
    "                                 anchors=ANCHORS,\n",
    "                                 anchor_masks=ANCHOR_MASKS,\n",
    "                                 valid_thresh = VALID_THRESH)\n",
    "\n",
    "        bboxes_data = bboxes.numpy()\n",
    "        scores_data = scores.numpy()\n",
    "        result = multiclass_nms(bboxes_data, scores_data,\n",
    "                      score_thresh=VALID_THRESH, \n",
    "                      nms_thresh=NMS_THRESH, \n",
    "                      pre_nms_topk=NMS_TOPK, \n",
    "                      pos_nms_topk=NMS_POSK)\n",
    "        for j in range(len(result)):\n",
    "            result_j = result[j]\n",
    "            img_name_j = img_name[j]\n",
    "            total_results.append([img_name_j, result_j.tolist()])\n",
    "        print('processed {} pictures'.format(len(total_results)))\n",
    "\n",
    "    print('')\n",
    "    json.dump(total_results, open('pred_results.json', 'w'))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "json文件中保存着测试结果，是包含所有图片预测结果的list，其构成如下：\n",
    "\n",
    "    [[img_name, [[label, score, x1, y1, x2, y2], ..., [label, score, x1, y1, x2, y2]]], \n",
    "     [img_name, [[label, score, x1, y1, x2, y2], ..., [label, score, x1, y1, x2, y2]]],\n",
    "      ...\n",
    "     [img_name, [[label, score, x1, y1, x2, y2],..., [label, score, x1, y1, x2, y2]]]]\n",
    "\n",
    "list中的每一个元素是一张图片的预测结果，list的总长度等于图片的数目，每张图片预测结果的格式是：\n",
    "\n",
    "     [img_name, [[label, score, x1, y1, x2, y2],..., [label, score, x1, y1, x2, y2]]]\n",
    "     \n",
    "其中第一个元素是图片名称image_name，第二个元素是包含该图片所有预测框的list， 预测框列表：\n",
    "\n",
    "     [[label, score, x1, x2, y1, y2],..., [label, score, x1, y1, x2, y2]]\n",
    "     \n",
    "预测框列表中每个元素[label, score, x1, y1, x2, y2]描述了一个预测框，label是预测框所属类别标签，score是预测框的得分；x1, y1, x2, y2对应预测框左上角坐标(x1, y1)，右下角坐标(x2, y2)。每张图片可能有很多个预测框，则将其全部放在预测框列表中。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 模型效果及可视化展示\n",
    "\n",
    "上面的程序展示了如何读取测试数据集的图片，并将最终结果保存在json格式的文件中。为了更直观的给读者展示模型效果，下面的程序添加了如何读取单张图片，并画出其产生的预测框。\n",
    "\n",
    "1. 创建数据读取器以读取单张图片的数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读取单张测试图片\n",
    "def single_image_data_loader(filename, test_image_size=608, mode='test'):\n",
    "    \"\"\"\n",
    "    加载测试用的图片，测试数据没有groundtruth标签\n",
    "    \"\"\"\n",
    "    batch_size= 1\n",
    "    def reader():\n",
    "        batch_data = []\n",
    "        img_size = test_image_size\n",
    "        file_path = os.path.join(filename)\n",
    "        img = cv2.imread(file_path)\n",
    "        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "        H = img.shape[0]\n",
    "        W = img.shape[1]\n",
    "        img = cv2.resize(img, (img_size, img_size))\n",
    "\n",
    "        mean = [0.485, 0.456, 0.406]\n",
    "        std = [0.229, 0.224, 0.225]\n",
    "        mean = np.array(mean).reshape((1, 1, -1))\n",
    "        std = np.array(std).reshape((1, 1, -1))\n",
    "        out_img = (img / 255.0 - mean) / std\n",
    "        out_img = out_img.astype('float32').transpose((2, 0, 1))\n",
    "        img = out_img #np.transpose(out_img, (2,0,1))\n",
    "        im_shape = [H, W]\n",
    "\n",
    "        batch_data.append((image_name.split('.')[0], img, im_shape))\n",
    "        if len(batch_data) == batch_size:\n",
    "            yield make_test_array(batch_data)\n",
    "            batch_data = []\n",
    "\n",
    "    return reader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. 定义绘制预测框的画图函数，代码如下。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义画图函数\n",
    "INSECT_NAMES = ['Boerner', 'Leconte', 'Linnaeus', \n",
    "                'acuminatus', 'armandi', 'coleoptera', 'linnaeus']\n",
    "\n",
    "# 定义画矩形框的函数 \n",
    "def draw_rectangle(currentAxis, bbox, edgecolor = 'k', facecolor = 'y', fill=False, linestyle='-'):\n",
    "    # currentAxis，坐标轴，通过plt.gca()获取\n",
    "    # bbox，边界框，包含四个数值的list， [x1, y1, x2, y2]\n",
    "    # edgecolor，边框线条颜色\n",
    "    # facecolor，填充颜色\n",
    "    # fill, 是否填充\n",
    "    # linestype，边框线型\n",
    "    # patches.Rectangle需要传入左上角坐标、矩形区域的宽度、高度等参数\n",
    "    rect=patches.Rectangle((bbox[0], bbox[1]), bbox[2]-bbox[0]+1, bbox[3]-bbox[1]+1, linewidth=1,\n",
    "                           edgecolor=edgecolor,facecolor=facecolor,fill=fill, linestyle=linestyle)\n",
    "    currentAxis.add_patch(rect)\n",
    "\n",
    "# 定义绘制预测结果的函数\n",
    "def draw_results(result, filename, draw_thresh=0.5):\n",
    "    plt.figure(figsize=(10, 10))\n",
    "    im = imread(filename)\n",
    "    plt.imshow(im)\n",
    "    currentAxis=plt.gca()\n",
    "    colors = ['r', 'g', 'b', 'k', 'y', 'c', 'purple']\n",
    "    for item in result:\n",
    "        box = item[2:6]\n",
    "        label = int(item[0])\n",
    "        name = INSECT_NAMES[label]\n",
    "        if item[1] > draw_thresh:\n",
    "            draw_rectangle(currentAxis, box, edgecolor = colors[label])\n",
    "            plt.text(box[0], box[1], name, fontsize=12, color=colors[label])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. 使用上面定义的single_image_data_loader函数读取指定的图片，输入网络并计算出预测框和得分，然后使用多分类非极大值抑制消除冗余的框。将最终结果画图展示出来。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "import paddle\n",
    "\n",
    "ANCHORS = [10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326]\n",
    "ANCHOR_MASKS = [[6, 7, 8], [3, 4, 5], [0, 1, 2]]\n",
    "VALID_THRESH = 0.01\n",
    "NMS_TOPK = 400\n",
    "NMS_POSK = 100\n",
    "NMS_THRESH = 0.45\n",
    "\n",
    "NUM_CLASSES = 7\n",
    "if __name__ == '__main__':\n",
    "    image_name = '/home/aistudio/work/insects/test/images/2599.jpeg'\n",
    "    params_file_path = '/home/aistudio/yolo_epoch50.pdparams'\n",
    "\n",
    "    model = YOLOv3(num_classes=NUM_CLASSES)\n",
    "    model_state_dict = paddle.load(params_file_path)\n",
    "    model.load_dict(model_state_dict)\n",
    "    model.eval()\n",
    "\n",
    "    total_results = []\n",
    "    test_loader = single_image_data_loader(image_name, mode='test')\n",
    "    for i, data in enumerate(test_loader()):\n",
    "        img_name, img_data, img_scale_data = data\n",
    "        img = paddle.to_tensor(img_data)\n",
    "        img_scale = paddle.to_tensor(img_scale_data)\n",
    "\n",
    "        outputs = model.forward(img)\n",
    "        bboxes, scores = model.get_pred(outputs,\n",
    "                                 im_shape=img_scale,\n",
    "                                 anchors=ANCHORS,\n",
    "                                 anchor_masks=ANCHOR_MASKS,\n",
    "                                 valid_thresh = VALID_THRESH)\n",
    "\n",
    "        bboxes_data = bboxes.numpy()\n",
    "        scores_data = scores.numpy()\n",
    "        results = multiclass_nms(bboxes_data, scores_data,\n",
    "                      score_thresh=VALID_THRESH, \n",
    "                      nms_thresh=NMS_THRESH, \n",
    "                      pre_nms_topk=NMS_TOPK, \n",
    "                      pos_nms_topk=NMS_POSK)\n",
    "\n",
    "result = results[0]\n",
    "draw_results(result, image_name, draw_thresh=0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过上面的程序，清晰的给读者展示了如何使用训练好的权重，对图片进行预测并将结果可视化。最终输出的图片上，检测出了每个昆虫，标出了它们的边界框和具体类别。\n",
    "\n",
    "\n",
    "## 总结\n",
    "   本章系统化的介绍了计算机视觉的各种网络结构和发展历程，并以图像分类和目标检测两个任务为例，展示了ResNet和YOLOv3等算法的实现。期望读者不仅掌握了计算机视觉模型搭建方法，也能够对提取视觉特征的方法有更深入的认知。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
